+++ /dev/null
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Preamble
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-X : ARRAY BITVECTOR(12) OF BITVECTOR(1);
-Y : ARRAY BITVECTOR(12) OF BITVECTOR(1);
-ZY : ARRAY BITVECTOR(12) OF BITVECTOR(1);
-LX : ARRAY BITVECTOR(6) OF BITVECTOR(1);
-LX_i : BITVECTOR(6);
-ASSERT (BVLE(0bin000000, LX_i) AND BVLE(LX_i, 0bin101101));
-RX : ARRAY BITVECTOR(6) OF BITVECTOR(1);
-RX_i : BITVECTOR(6);
-ASSERT (BVLE(0bin000000, RX_i) AND BVLE(RX_i, 0bin101101));
-LY : ARRAY BITVECTOR(6) OF BITVECTOR(1);
-LY_i : BITVECTOR(6);
-ASSERT (BVLE(0bin000000, LY_i) AND BVLE(LY_i, 0bin101101));
-RY : ARRAY BITVECTOR(6) OF BITVECTOR(1);
-RY_i : BITVECTOR(6);
-ASSERT (BVLE(0bin000000, RY_i) AND BVLE(RY_i, 0bin101101));
-LT : ARRAY BITVECTOR(12) OF BITVECTOR(1);
-RT : ARRAY BITVECTOR(12) OF BITVECTOR(1);
-final_Ex : ARRAY BITVECTOR(12) OF BITVECTOR(8);
-final_Ey : ARRAY BITVECTOR(12) OF BITVECTOR(8);
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Constraints
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-%%%%%%%%%% (0) %%%%%%%%%%
-ASSERT(X[0bin000000000000]=X[0bin000000000000]);
-ASSERT(Y[0bin000000000000]=Y[0bin000000000000]);
-ASSERT(X[0bin000000000001]=X[0bin000000101110]);
-ASSERT(Y[0bin000000000001]=Y[0bin000000101110]);
-ASSERT(X[0bin000000000010]=X[0bin000001011100]);
-ASSERT(Y[0bin000000000010]=Y[0bin000001011100]);
-ASSERT(X[0bin000000000011]=X[0bin000010001010]);
-ASSERT(Y[0bin000000000011]=Y[0bin000010001010]);
-ASSERT(X[0bin000000000100]=X[0bin000010111000]);
-ASSERT(Y[0bin000000000100]=Y[0bin000010111000]);
-ASSERT(X[0bin000000000101]=X[0bin000011100110]);
-ASSERT(Y[0bin000000000101]=Y[0bin000011100110]);
-ASSERT(X[0bin000000000110]=X[0bin000100010100]);
-ASSERT(Y[0bin000000000110]=Y[0bin000100010100]);
-ASSERT(X[0bin000000000111]=X[0bin000101000010]);
-ASSERT(Y[0bin000000000111]=Y[0bin000101000010]);
-ASSERT(X[0bin000000001000]=X[0bin000101110000]);
-ASSERT(Y[0bin000000001000]=Y[0bin000101110000]);
-ASSERT(X[0bin000000001001]=X[0bin000110011110]);
-ASSERT(Y[0bin000000001001]=Y[0bin000110011110]);
-ASSERT(X[0bin000000001010]=X[0bin000111001100]);
-ASSERT(Y[0bin000000001010]=Y[0bin000111001100]);
-ASSERT(X[0bin000000001011]=X[0bin000111111010]);
-ASSERT(Y[0bin000000001011]=Y[0bin000111111010]);
-ASSERT(X[0bin000000001100]=X[0bin001000101000]);
-ASSERT(Y[0bin000000001100]=Y[0bin001000101000]);
-ASSERT(X[0bin000000001101]=X[0bin001001010110]);
-ASSERT(Y[0bin000000001101]=Y[0bin001001010110]);
-ASSERT(X[0bin000000001110]=X[0bin001010000100]);
-ASSERT(Y[0bin000000001110]=Y[0bin001010000100]);
-ASSERT(X[0bin000000001111]=X[0bin001010110010]);
-ASSERT(Y[0bin000000001111]=Y[0bin001010110010]);
-ASSERT(X[0bin000000010000]=X[0bin001011100000]);
-ASSERT(Y[0bin000000010000]=Y[0bin001011100000]);
-ASSERT(X[0bin000000010001]=X[0bin001100001110]);
-ASSERT(Y[0bin000000010001]=Y[0bin001100001110]);
-ASSERT(X[0bin000000010010]=X[0bin001100111100]);
-ASSERT(Y[0bin000000010010]=Y[0bin001100111100]);
-ASSERT(X[0bin000000010011]=X[0bin001101101010]);
-ASSERT(Y[0bin000000010011]=Y[0bin001101101010]);
-ASSERT(X[0bin000000010100]=X[0bin001110011000]);
-ASSERT(Y[0bin000000010100]=Y[0bin001110011000]);
-ASSERT(X[0bin000000010101]=X[0bin001111000110]);
-ASSERT(Y[0bin000000010101]=Y[0bin001111000110]);
-ASSERT(X[0bin000000010110]=X[0bin001111110100]);
-ASSERT(Y[0bin000000010110]=Y[0bin001111110100]);
-ASSERT(X[0bin000000010111]=X[0bin010000100010]);
-ASSERT(Y[0bin000000010111]=Y[0bin010000100010]);
-ASSERT(X[0bin000000011000]=X[0bin010001010000]);
-ASSERT(Y[0bin000000011000]=Y[0bin010001010000]);
-ASSERT(X[0bin000000011001]=X[0bin010001111110]);
-ASSERT(Y[0bin000000011001]=Y[0bin010001111110]);
-ASSERT(X[0bin000000011010]=X[0bin010010101100]);
-ASSERT(Y[0bin000000011010]=Y[0bin010010101100]);
-ASSERT(X[0bin000000011011]=X[0bin010011011010]);
-ASSERT(Y[0bin000000011011]=Y[0bin010011011010]);
-ASSERT(X[0bin000000011100]=X[0bin010100001000]);
-ASSERT(Y[0bin000000011100]=Y[0bin010100001000]);
-ASSERT(X[0bin000000011101]=X[0bin010100110110]);
-ASSERT(Y[0bin000000011101]=Y[0bin010100110110]);
-ASSERT(X[0bin000000011110]=X[0bin010101100100]);
-ASSERT(Y[0bin000000011110]=Y[0bin010101100100]);
-ASSERT(X[0bin000000011111]=X[0bin010110010010]);
-ASSERT(Y[0bin000000011111]=Y[0bin010110010010]);
-ASSERT(X[0bin000000100000]=X[0bin010111000000]);
-ASSERT(Y[0bin000000100000]=Y[0bin010111000000]);
-ASSERT(X[0bin000000100001]=X[0bin010111101110]);
-ASSERT(Y[0bin000000100001]=Y[0bin010111101110]);
-ASSERT(X[0bin000000100010]=X[0bin011000011100]);
-ASSERT(Y[0bin000000100010]=Y[0bin011000011100]);
-ASSERT(X[0bin000000100011]=X[0bin011001001010]);
-ASSERT(Y[0bin000000100011]=Y[0bin011001001010]);
-ASSERT(X[0bin000000100100]=X[0bin011001111000]);
-ASSERT(Y[0bin000000100100]=Y[0bin011001111000]);
-ASSERT(X[0bin000000100101]=X[0bin011010100110]);
-ASSERT(Y[0bin000000100101]=Y[0bin011010100110]);
-ASSERT(X[0bin000000100110]=X[0bin011011010100]);
-ASSERT(Y[0bin000000100110]=Y[0bin011011010100]);
-ASSERT(X[0bin000000100111]=X[0bin011100000010]);
-ASSERT(Y[0bin000000100111]=Y[0bin011100000010]);
-ASSERT(X[0bin000000101000]=X[0bin011100110000]);
-ASSERT(Y[0bin000000101000]=Y[0bin011100110000]);
-ASSERT(X[0bin000000101001]=X[0bin011101011110]);
-ASSERT(Y[0bin000000101001]=Y[0bin011101011110]);
-ASSERT(X[0bin000000101010]=X[0bin011110001100]);
-ASSERT(Y[0bin000000101010]=Y[0bin011110001100]);
-ASSERT(X[0bin000000101011]=X[0bin011110111010]);
-ASSERT(Y[0bin000000101011]=Y[0bin011110111010]);
-ASSERT(X[0bin000000101100]=X[0bin011111101000]);
-ASSERT(Y[0bin000000101100]=Y[0bin011111101000]);
-ASSERT(X[0bin000000101101]=X[0bin100000010110]);
-ASSERT(Y[0bin000000101101]=Y[0bin100000010110]);
-ASSERT(X[0bin000000101110]=X[0bin000000000001]);
-ASSERT(Y[0bin000000101110]=Y[0bin000000000001]);
-ASSERT(X[0bin000000101111]=X[0bin000000101111]);
-ASSERT(Y[0bin000000101111]=Y[0bin000000101111]);
-ASSERT(X[0bin000000110000]=X[0bin000001011101]);
-ASSERT(Y[0bin000000110000]=Y[0bin000001011101]);
-ASSERT(X[0bin000000110001]=X[0bin000010001011]);
-ASSERT(Y[0bin000000110001]=Y[0bin000010001011]);
-ASSERT(X[0bin000000110010]=X[0bin000010111001]);
-ASSERT(Y[0bin000000110010]=Y[0bin000010111001]);
-ASSERT(X[0bin000000110011]=X[0bin000011100111]);
-ASSERT(Y[0bin000000110011]=Y[0bin000011100111]);
-ASSERT(X[0bin000000110100]=X[0bin000100010101]);
-ASSERT(Y[0bin000000110100]=Y[0bin000100010101]);
-ASSERT(X[0bin000000110101]=X[0bin000101000011]);
-ASSERT(Y[0bin000000110101]=Y[0bin000101000011]);
-ASSERT(X[0bin000000110110]=X[0bin000101110001]);
-ASSERT(Y[0bin000000110110]=Y[0bin000101110001]);
-ASSERT(X[0bin000000110111]=X[0bin000110011111]);
-ASSERT(Y[0bin000000110111]=Y[0bin000110011111]);
-ASSERT(X[0bin000000111000]=X[0bin000111001101]);
-ASSERT(Y[0bin000000111000]=Y[0bin000111001101]);
-ASSERT(X[0bin000000111001]=X[0bin000111111011]);
-ASSERT(Y[0bin000000111001]=Y[0bin000111111011]);
-ASSERT(X[0bin000000111010]=X[0bin001000101001]);
-ASSERT(Y[0bin000000111010]=Y[0bin001000101001]);
-ASSERT(X[0bin000000111011]=X[0bin001001010111]);
-ASSERT(Y[0bin000000111011]=Y[0bin001001010111]);
-ASSERT(X[0bin000000111100]=X[0bin001010000101]);
-ASSERT(Y[0bin000000111100]=Y[0bin001010000101]);
-ASSERT(X[0bin000000111101]=X[0bin001010110011]);
-ASSERT(Y[0bin000000111101]=Y[0bin001010110011]);
-ASSERT(X[0bin000000111110]=X[0bin001011100001]);
-ASSERT(Y[0bin000000111110]=Y[0bin001011100001]);
-ASSERT(X[0bin000000111111]=X[0bin001100001111]);
-ASSERT(Y[0bin000000111111]=Y[0bin001100001111]);
-ASSERT(X[0bin000001000000]=X[0bin001100111101]);
-ASSERT(Y[0bin000001000000]=Y[0bin001100111101]);
-ASSERT(X[0bin000001000001]=X[0bin001101101011]);
-ASSERT(Y[0bin000001000001]=Y[0bin001101101011]);
-ASSERT(X[0bin000001000010]=X[0bin001110011001]);
-ASSERT(Y[0bin000001000010]=Y[0bin001110011001]);
-ASSERT(X[0bin000001000011]=X[0bin001111000111]);
-ASSERT(Y[0bin000001000011]=Y[0bin001111000111]);
-ASSERT(X[0bin000001000100]=X[0bin001111110101]);
-ASSERT(Y[0bin000001000100]=Y[0bin001111110101]);
-ASSERT(X[0bin000001000101]=X[0bin010000100011]);
-ASSERT(Y[0bin000001000101]=Y[0bin010000100011]);
-ASSERT(X[0bin000001000110]=X[0bin010001010001]);
-ASSERT(Y[0bin000001000110]=Y[0bin010001010001]);
-ASSERT(X[0bin000001000111]=X[0bin010001111111]);
-ASSERT(Y[0bin000001000111]=Y[0bin010001111111]);
-ASSERT(X[0bin000001001000]=X[0bin010010101101]);
-ASSERT(Y[0bin000001001000]=Y[0bin010010101101]);
-ASSERT(X[0bin000001001001]=X[0bin010011011011]);
-ASSERT(Y[0bin000001001001]=Y[0bin010011011011]);
-ASSERT(X[0bin000001001010]=X[0bin010100001001]);
-ASSERT(Y[0bin000001001010]=Y[0bin010100001001]);
-ASSERT(X[0bin000001001011]=X[0bin010100110111]);
-ASSERT(Y[0bin000001001011]=Y[0bin010100110111]);
-ASSERT(X[0bin000001001100]=X[0bin010101100101]);
-ASSERT(Y[0bin000001001100]=Y[0bin010101100101]);
-ASSERT(X[0bin000001001101]=X[0bin010110010011]);
-ASSERT(Y[0bin000001001101]=Y[0bin010110010011]);
-ASSERT(X[0bin000001001110]=X[0bin010111000001]);
-ASSERT(Y[0bin000001001110]=Y[0bin010111000001]);
-ASSERT(X[0bin000001001111]=X[0bin010111101111]);
-ASSERT(Y[0bin000001001111]=Y[0bin010111101111]);
-ASSERT(X[0bin000001010000]=X[0bin011000011101]);
-ASSERT(Y[0bin000001010000]=Y[0bin011000011101]);
-ASSERT(X[0bin000001010001]=X[0bin011001001011]);
-ASSERT(Y[0bin000001010001]=Y[0bin011001001011]);
-ASSERT(X[0bin000001010010]=X[0bin011001111001]);
-ASSERT(Y[0bin000001010010]=Y[0bin011001111001]);
-ASSERT(X[0bin000001010011]=X[0bin011010100111]);
-ASSERT(Y[0bin000001010011]=Y[0bin011010100111]);
-ASSERT(X[0bin000001010100]=X[0bin011011010101]);
-ASSERT(Y[0bin000001010100]=Y[0bin011011010101]);
-ASSERT(X[0bin000001010101]=X[0bin011100000011]);
-ASSERT(Y[0bin000001010101]=Y[0bin011100000011]);
-ASSERT(X[0bin000001010110]=X[0bin011100110001]);
-ASSERT(Y[0bin000001010110]=Y[0bin011100110001]);
-ASSERT(X[0bin000001010111]=X[0bin011101011111]);
-ASSERT(Y[0bin000001010111]=Y[0bin011101011111]);
-ASSERT(X[0bin000001011000]=X[0bin011110001101]);
-ASSERT(Y[0bin000001011000]=Y[0bin011110001101]);
-ASSERT(X[0bin000001011001]=X[0bin011110111011]);
-ASSERT(Y[0bin000001011001]=Y[0bin011110111011]);
-ASSERT(X[0bin000001011010]=X[0bin011111101001]);
-ASSERT(Y[0bin000001011010]=Y[0bin011111101001]);
-ASSERT(X[0bin000001011011]=X[0bin100000010111]);
-ASSERT(Y[0bin000001011011]=Y[0bin100000010111]);
-ASSERT(X[0bin000001011100]=X[0bin000000000010]);
-ASSERT(Y[0bin000001011100]=Y[0bin000000000010]);
-ASSERT(X[0bin000001011101]=X[0bin000000110000]);
-ASSERT(Y[0bin000001011101]=Y[0bin000000110000]);
-ASSERT(X[0bin000001011110]=X[0bin000001011110]);
-ASSERT(Y[0bin000001011110]=Y[0bin000001011110]);
-ASSERT(X[0bin000001011111]=X[0bin000010001100]);
-ASSERT(Y[0bin000001011111]=Y[0bin000010001100]);
-ASSERT(X[0bin000001100000]=X[0bin000010111010]);
-ASSERT(Y[0bin000001100000]=Y[0bin000010111010]);
-ASSERT(X[0bin000001100001]=X[0bin000011101000]);
-ASSERT(Y[0bin000001100001]=Y[0bin000011101000]);
-ASSERT(X[0bin000001100010]=X[0bin000100010110]);
-ASSERT(Y[0bin000001100010]=Y[0bin000100010110]);
-ASSERT(X[0bin000001100011]=X[0bin000101000100]);
-ASSERT(Y[0bin000001100011]=Y[0bin000101000100]);
-ASSERT(X[0bin000001100100]=X[0bin000101110010]);
-ASSERT(Y[0bin000001100100]=Y[0bin000101110010]);
-ASSERT(X[0bin000001100101]=X[0bin000110100000]);
-ASSERT(Y[0bin000001100101]=Y[0bin000110100000]);
-ASSERT(X[0bin000001100110]=X[0bin000111001110]);
-ASSERT(Y[0bin000001100110]=Y[0bin000111001110]);
-ASSERT(X[0bin000001100111]=X[0bin000111111100]);
-ASSERT(Y[0bin000001100111]=Y[0bin000111111100]);
-ASSERT(X[0bin000001101000]=X[0bin001000101010]);
-ASSERT(Y[0bin000001101000]=Y[0bin001000101010]);
-ASSERT(X[0bin000001101001]=X[0bin001001011000]);
-ASSERT(Y[0bin000001101001]=Y[0bin001001011000]);
-ASSERT(X[0bin000001101010]=X[0bin001010000110]);
-ASSERT(Y[0bin000001101010]=Y[0bin001010000110]);
-ASSERT(X[0bin000001101011]=X[0bin001010110100]);
-ASSERT(Y[0bin000001101011]=Y[0bin001010110100]);
-ASSERT(X[0bin000001101100]=X[0bin001011100010]);
-ASSERT(Y[0bin000001101100]=Y[0bin001011100010]);
-ASSERT(X[0bin000001101101]=X[0bin001100010000]);
-ASSERT(Y[0bin000001101101]=Y[0bin001100010000]);
-ASSERT(X[0bin000001101110]=X[0bin001100111110]);
-ASSERT(Y[0bin000001101110]=Y[0bin001100111110]);
-ASSERT(X[0bin000001101111]=X[0bin001101101100]);
-ASSERT(Y[0bin000001101111]=Y[0bin001101101100]);
-ASSERT(X[0bin000001110000]=X[0bin001110011010]);
-ASSERT(Y[0bin000001110000]=Y[0bin001110011010]);
-ASSERT(X[0bin000001110001]=X[0bin001111001000]);
-ASSERT(Y[0bin000001110001]=Y[0bin001111001000]);
-ASSERT(X[0bin000001110010]=X[0bin001111110110]);
-ASSERT(Y[0bin000001110010]=Y[0bin001111110110]);
-ASSERT(X[0bin000001110011]=X[0bin010000100100]);
-ASSERT(Y[0bin000001110011]=Y[0bin010000100100]);
-ASSERT(X[0bin000001110100]=X[0bin010001010010]);
-ASSERT(Y[0bin000001110100]=Y[0bin010001010010]);
-ASSERT(X[0bin000001110101]=X[0bin010010000000]);
-ASSERT(Y[0bin000001110101]=Y[0bin010010000000]);
-ASSERT(X[0bin000001110110]=X[0bin010010101110]);
-ASSERT(Y[0bin000001110110]=Y[0bin010010101110]);
-ASSERT(X[0bin000001110111]=X[0bin010011011100]);
-ASSERT(Y[0bin000001110111]=Y[0bin010011011100]);
-ASSERT(X[0bin000001111000]=X[0bin010100001010]);
-ASSERT(Y[0bin000001111000]=Y[0bin010100001010]);
-ASSERT(X[0bin000001111001]=X[0bin010100111000]);
-ASSERT(Y[0bin000001111001]=Y[0bin010100111000]);
-ASSERT(X[0bin000001111010]=X[0bin010101100110]);
-ASSERT(Y[0bin000001111010]=Y[0bin010101100110]);
-ASSERT(X[0bin000001111011]=X[0bin010110010100]);
-ASSERT(Y[0bin000001111011]=Y[0bin010110010100]);
-ASSERT(X[0bin000001111100]=X[0bin010111000010]);
-ASSERT(Y[0bin000001111100]=Y[0bin010111000010]);
-ASSERT(X[0bin000001111101]=X[0bin010111110000]);
-ASSERT(Y[0bin000001111101]=Y[0bin010111110000]);
-ASSERT(X[0bin000001111110]=X[0bin011000011110]);
-ASSERT(Y[0bin000001111110]=Y[0bin011000011110]);
-ASSERT(X[0bin000001111111]=X[0bin011001001100]);
-ASSERT(Y[0bin000001111111]=Y[0bin011001001100]);
-ASSERT(X[0bin000010000000]=X[0bin011001111010]);
-ASSERT(Y[0bin000010000000]=Y[0bin011001111010]);
-ASSERT(X[0bin000010000001]=X[0bin011010101000]);
-ASSERT(Y[0bin000010000001]=Y[0bin011010101000]);
-ASSERT(X[0bin000010000010]=X[0bin011011010110]);
-ASSERT(Y[0bin000010000010]=Y[0bin011011010110]);
-ASSERT(X[0bin000010000011]=X[0bin011100000100]);
-ASSERT(Y[0bin000010000011]=Y[0bin011100000100]);
-ASSERT(X[0bin000010000100]=X[0bin011100110010]);
-ASSERT(Y[0bin000010000100]=Y[0bin011100110010]);
-ASSERT(X[0bin000010000101]=X[0bin011101100000]);
-ASSERT(Y[0bin000010000101]=Y[0bin011101100000]);
-ASSERT(X[0bin000010000110]=X[0bin011110001110]);
-ASSERT(Y[0bin000010000110]=Y[0bin011110001110]);
-ASSERT(X[0bin000010000111]=X[0bin011110111100]);
-ASSERT(Y[0bin000010000111]=Y[0bin011110111100]);
-ASSERT(X[0bin000010001000]=X[0bin011111101010]);
-ASSERT(Y[0bin000010001000]=Y[0bin011111101010]);
-ASSERT(X[0bin000010001001]=X[0bin100000011000]);
-ASSERT(Y[0bin000010001001]=Y[0bin100000011000]);
-ASSERT(X[0bin000010001010]=X[0bin000000000011]);
-ASSERT(Y[0bin000010001010]=Y[0bin000000000011]);
-ASSERT(X[0bin000010001011]=X[0bin000000110001]);
-ASSERT(Y[0bin000010001011]=Y[0bin000000110001]);
-ASSERT(X[0bin000010001100]=X[0bin000001011111]);
-ASSERT(Y[0bin000010001100]=Y[0bin000001011111]);
-ASSERT(X[0bin000010001101]=X[0bin000010001101]);
-ASSERT(Y[0bin000010001101]=Y[0bin000010001101]);
-ASSERT(X[0bin000010001110]=X[0bin000010111011]);
-ASSERT(Y[0bin000010001110]=Y[0bin000010111011]);
-ASSERT(X[0bin000010001111]=X[0bin000011101001]);
-ASSERT(Y[0bin000010001111]=Y[0bin000011101001]);
-ASSERT(X[0bin000010010000]=X[0bin000100010111]);
-ASSERT(Y[0bin000010010000]=Y[0bin000100010111]);
-ASSERT(X[0bin000010010001]=X[0bin000101000101]);
-ASSERT(Y[0bin000010010001]=Y[0bin000101000101]);
-ASSERT(X[0bin000010010010]=X[0bin000101110011]);
-ASSERT(Y[0bin000010010010]=Y[0bin000101110011]);
-ASSERT(X[0bin000010010011]=X[0bin000110100001]);
-ASSERT(Y[0bin000010010011]=Y[0bin000110100001]);
-ASSERT(X[0bin000010010100]=X[0bin000111001111]);
-ASSERT(Y[0bin000010010100]=Y[0bin000111001111]);
-ASSERT(X[0bin000010010101]=X[0bin000111111101]);
-ASSERT(Y[0bin000010010101]=Y[0bin000111111101]);
-ASSERT(X[0bin000010010110]=X[0bin001000101011]);
-ASSERT(Y[0bin000010010110]=Y[0bin001000101011]);
-ASSERT(X[0bin000010010111]=X[0bin001001011001]);
-ASSERT(Y[0bin000010010111]=Y[0bin001001011001]);
-ASSERT(X[0bin000010011000]=X[0bin001010000111]);
-ASSERT(Y[0bin000010011000]=Y[0bin001010000111]);
-ASSERT(X[0bin000010011001]=X[0bin001010110101]);
-ASSERT(Y[0bin000010011001]=Y[0bin001010110101]);
-ASSERT(X[0bin000010011010]=X[0bin001011100011]);
-ASSERT(Y[0bin000010011010]=Y[0bin001011100011]);
-ASSERT(X[0bin000010011011]=X[0bin001100010001]);
-ASSERT(Y[0bin000010011011]=Y[0bin001100010001]);
-ASSERT(X[0bin000010011100]=X[0bin001100111111]);
-ASSERT(Y[0bin000010011100]=Y[0bin001100111111]);
-ASSERT(X[0bin000010011101]=X[0bin001101101101]);
-ASSERT(Y[0bin000010011101]=Y[0bin001101101101]);
-ASSERT(X[0bin000010011110]=X[0bin001110011011]);
-ASSERT(Y[0bin000010011110]=Y[0bin001110011011]);
-ASSERT(X[0bin000010011111]=X[0bin001111001001]);
-ASSERT(Y[0bin000010011111]=Y[0bin001111001001]);
-ASSERT(X[0bin000010100000]=X[0bin001111110111]);
-ASSERT(Y[0bin000010100000]=Y[0bin001111110111]);
-ASSERT(X[0bin000010100001]=X[0bin010000100101]);
-ASSERT(Y[0bin000010100001]=Y[0bin010000100101]);
-ASSERT(X[0bin000010100010]=X[0bin010001010011]);
-ASSERT(Y[0bin000010100010]=Y[0bin010001010011]);
-ASSERT(X[0bin000010100011]=X[0bin010010000001]);
-ASSERT(Y[0bin000010100011]=Y[0bin010010000001]);
-ASSERT(X[0bin000010100100]=X[0bin010010101111]);
-ASSERT(Y[0bin000010100100]=Y[0bin010010101111]);
-ASSERT(X[0bin000010100101]=X[0bin010011011101]);
-ASSERT(Y[0bin000010100101]=Y[0bin010011011101]);
-ASSERT(X[0bin000010100110]=X[0bin010100001011]);
-ASSERT(Y[0bin000010100110]=Y[0bin010100001011]);
-ASSERT(X[0bin000010100111]=X[0bin010100111001]);
-ASSERT(Y[0bin000010100111]=Y[0bin010100111001]);
-ASSERT(X[0bin000010101000]=X[0bin010101100111]);
-ASSERT(Y[0bin000010101000]=Y[0bin010101100111]);
-ASSERT(X[0bin000010101001]=X[0bin010110010101]);
-ASSERT(Y[0bin000010101001]=Y[0bin010110010101]);
-ASSERT(X[0bin000010101010]=X[0bin010111000011]);
-ASSERT(Y[0bin000010101010]=Y[0bin010111000011]);
-ASSERT(X[0bin000010101011]=X[0bin010111110001]);
-ASSERT(Y[0bin000010101011]=Y[0bin010111110001]);
-ASSERT(X[0bin000010101100]=X[0bin011000011111]);
-ASSERT(Y[0bin000010101100]=Y[0bin011000011111]);
-ASSERT(X[0bin000010101101]=X[0bin011001001101]);
-ASSERT(Y[0bin000010101101]=Y[0bin011001001101]);
-ASSERT(X[0bin000010101110]=X[0bin011001111011]);
-ASSERT(Y[0bin000010101110]=Y[0bin011001111011]);
-ASSERT(X[0bin000010101111]=X[0bin011010101001]);
-ASSERT(Y[0bin000010101111]=Y[0bin011010101001]);
-ASSERT(X[0bin000010110000]=X[0bin011011010111]);
-ASSERT(Y[0bin000010110000]=Y[0bin011011010111]);
-ASSERT(X[0bin000010110001]=X[0bin011100000101]);
-ASSERT(Y[0bin000010110001]=Y[0bin011100000101]);
-ASSERT(X[0bin000010110010]=X[0bin011100110011]);
-ASSERT(Y[0bin000010110010]=Y[0bin011100110011]);
-ASSERT(X[0bin000010110011]=X[0bin011101100001]);
-ASSERT(Y[0bin000010110011]=Y[0bin011101100001]);
-ASSERT(X[0bin000010110100]=X[0bin011110001111]);
-ASSERT(Y[0bin000010110100]=Y[0bin011110001111]);
-ASSERT(X[0bin000010110101]=X[0bin011110111101]);
-ASSERT(Y[0bin000010110101]=Y[0bin011110111101]);
-ASSERT(X[0bin000010110110]=X[0bin011111101011]);
-ASSERT(Y[0bin000010110110]=Y[0bin011111101011]);
-ASSERT(X[0bin000010110111]=X[0bin100000011001]);
-ASSERT(Y[0bin000010110111]=Y[0bin100000011001]);
-ASSERT(X[0bin000010111000]=X[0bin000000000100]);
-ASSERT(Y[0bin000010111000]=Y[0bin000000000100]);
-ASSERT(X[0bin000010111001]=X[0bin000000110010]);
-ASSERT(Y[0bin000010111001]=Y[0bin000000110010]);
-ASSERT(X[0bin000010111010]=X[0bin000001100000]);
-ASSERT(Y[0bin000010111010]=Y[0bin000001100000]);
-ASSERT(X[0bin000010111011]=X[0bin000010001110]);
-ASSERT(Y[0bin000010111011]=Y[0bin000010001110]);
-ASSERT(X[0bin000010111100]=X[0bin000010111100]);
-ASSERT(Y[0bin000010111100]=Y[0bin000010111100]);
-ASSERT(X[0bin000010111101]=X[0bin000011101010]);
-ASSERT(Y[0bin000010111101]=Y[0bin000011101010]);
-ASSERT(X[0bin000010111110]=X[0bin000100011000]);
-ASSERT(Y[0bin000010111110]=Y[0bin000100011000]);
-ASSERT(X[0bin000010111111]=X[0bin000101000110]);
-ASSERT(Y[0bin000010111111]=Y[0bin000101000110]);
-ASSERT(X[0bin000011000000]=X[0bin000101110100]);
-ASSERT(Y[0bin000011000000]=Y[0bin000101110100]);
-ASSERT(X[0bin000011000001]=X[0bin000110100010]);
-ASSERT(Y[0bin000011000001]=Y[0bin000110100010]);
-ASSERT(X[0bin000011000010]=X[0bin000111010000]);
-ASSERT(Y[0bin000011000010]=Y[0bin000111010000]);
-ASSERT(X[0bin000011000011]=X[0bin000111111110]);
-ASSERT(Y[0bin000011000011]=Y[0bin000111111110]);
-ASSERT(X[0bin000011000100]=X[0bin001000101100]);
-ASSERT(Y[0bin000011000100]=Y[0bin001000101100]);
-ASSERT(X[0bin000011000101]=X[0bin001001011010]);
-ASSERT(Y[0bin000011000101]=Y[0bin001001011010]);
-ASSERT(X[0bin000011000110]=X[0bin001010001000]);
-ASSERT(Y[0bin000011000110]=Y[0bin001010001000]);
-ASSERT(X[0bin000011000111]=X[0bin001010110110]);
-ASSERT(Y[0bin000011000111]=Y[0bin001010110110]);
-ASSERT(X[0bin000011001000]=X[0bin001011100100]);
-ASSERT(Y[0bin000011001000]=Y[0bin001011100100]);
-ASSERT(X[0bin000011001001]=X[0bin001100010010]);
-ASSERT(Y[0bin000011001001]=Y[0bin001100010010]);
-ASSERT(X[0bin000011001010]=X[0bin001101000000]);
-ASSERT(Y[0bin000011001010]=Y[0bin001101000000]);
-ASSERT(X[0bin000011001011]=X[0bin001101101110]);
-ASSERT(Y[0bin000011001011]=Y[0bin001101101110]);
-ASSERT(X[0bin000011001100]=X[0bin001110011100]);
-ASSERT(Y[0bin000011001100]=Y[0bin001110011100]);
-ASSERT(X[0bin000011001101]=X[0bin001111001010]);
-ASSERT(Y[0bin000011001101]=Y[0bin001111001010]);
-ASSERT(X[0bin000011001110]=X[0bin001111111000]);
-ASSERT(Y[0bin000011001110]=Y[0bin001111111000]);
-ASSERT(X[0bin000011001111]=X[0bin010000100110]);
-ASSERT(Y[0bin000011001111]=Y[0bin010000100110]);
-ASSERT(X[0bin000011010000]=X[0bin010001010100]);
-ASSERT(Y[0bin000011010000]=Y[0bin010001010100]);
-ASSERT(X[0bin000011010001]=X[0bin010010000010]);
-ASSERT(Y[0bin000011010001]=Y[0bin010010000010]);
-ASSERT(X[0bin000011010010]=X[0bin010010110000]);
-ASSERT(Y[0bin000011010010]=Y[0bin010010110000]);
-ASSERT(X[0bin000011010011]=X[0bin010011011110]);
-ASSERT(Y[0bin000011010011]=Y[0bin010011011110]);
-ASSERT(X[0bin000011010100]=X[0bin010100001100]);
-ASSERT(Y[0bin000011010100]=Y[0bin010100001100]);
-ASSERT(X[0bin000011010101]=X[0bin010100111010]);
-ASSERT(Y[0bin000011010101]=Y[0bin010100111010]);
-ASSERT(X[0bin000011010110]=X[0bin010101101000]);
-ASSERT(Y[0bin000011010110]=Y[0bin010101101000]);
-ASSERT(X[0bin000011010111]=X[0bin010110010110]);
-ASSERT(Y[0bin000011010111]=Y[0bin010110010110]);
-ASSERT(X[0bin000011011000]=X[0bin010111000100]);
-ASSERT(Y[0bin000011011000]=Y[0bin010111000100]);
-ASSERT(X[0bin000011011001]=X[0bin010111110010]);
-ASSERT(Y[0bin000011011001]=Y[0bin010111110010]);
-ASSERT(X[0bin000011011010]=X[0bin011000100000]);
-ASSERT(Y[0bin000011011010]=Y[0bin011000100000]);
-ASSERT(X[0bin000011011011]=X[0bin011001001110]);
-ASSERT(Y[0bin000011011011]=Y[0bin011001001110]);
-ASSERT(X[0bin000011011100]=X[0bin011001111100]);
-ASSERT(Y[0bin000011011100]=Y[0bin011001111100]);
-ASSERT(X[0bin000011011101]=X[0bin011010101010]);
-ASSERT(Y[0bin000011011101]=Y[0bin011010101010]);
-ASSERT(X[0bin000011011110]=X[0bin011011011000]);
-ASSERT(Y[0bin000011011110]=Y[0bin011011011000]);
-ASSERT(X[0bin000011011111]=X[0bin011100000110]);
-ASSERT(Y[0bin000011011111]=Y[0bin011100000110]);
-ASSERT(X[0bin000011100000]=X[0bin011100110100]);
-ASSERT(Y[0bin000011100000]=Y[0bin011100110100]);
-ASSERT(X[0bin000011100001]=X[0bin011101100010]);
-ASSERT(Y[0bin000011100001]=Y[0bin011101100010]);
-ASSERT(X[0bin000011100010]=X[0bin011110010000]);
-ASSERT(Y[0bin000011100010]=Y[0bin011110010000]);
-ASSERT(X[0bin000011100011]=X[0bin011110111110]);
-ASSERT(Y[0bin000011100011]=Y[0bin011110111110]);
-ASSERT(X[0bin000011100100]=X[0bin011111101100]);
-ASSERT(Y[0bin000011100100]=Y[0bin011111101100]);
-ASSERT(X[0bin000011100101]=X[0bin100000011010]);
-ASSERT(Y[0bin000011100101]=Y[0bin100000011010]);
-ASSERT(X[0bin000011100110]=X[0bin000000000101]);
-ASSERT(Y[0bin000011100110]=Y[0bin000000000101]);
-ASSERT(X[0bin000011100111]=X[0bin000000110011]);
-ASSERT(Y[0bin000011100111]=Y[0bin000000110011]);
-ASSERT(X[0bin000011101000]=X[0bin000001100001]);
-ASSERT(Y[0bin000011101000]=Y[0bin000001100001]);
-ASSERT(X[0bin000011101001]=X[0bin000010001111]);
-ASSERT(Y[0bin000011101001]=Y[0bin000010001111]);
-ASSERT(X[0bin000011101010]=X[0bin000010111101]);
-ASSERT(Y[0bin000011101010]=Y[0bin000010111101]);
-ASSERT(X[0bin000011101011]=X[0bin000011101011]);
-ASSERT(Y[0bin000011101011]=Y[0bin000011101011]);
-ASSERT(X[0bin000011101100]=X[0bin000100011001]);
-ASSERT(Y[0bin000011101100]=Y[0bin000100011001]);
-ASSERT(X[0bin000011101101]=X[0bin000101000111]);
-ASSERT(Y[0bin000011101101]=Y[0bin000101000111]);
-ASSERT(X[0bin000011101110]=X[0bin000101110101]);
-ASSERT(Y[0bin000011101110]=Y[0bin000101110101]);
-ASSERT(X[0bin000011101111]=X[0bin000110100011]);
-ASSERT(Y[0bin000011101111]=Y[0bin000110100011]);
-ASSERT(X[0bin000011110000]=X[0bin000111010001]);
-ASSERT(Y[0bin000011110000]=Y[0bin000111010001]);
-ASSERT(X[0bin000011110001]=X[0bin000111111111]);
-ASSERT(Y[0bin000011110001]=Y[0bin000111111111]);
-ASSERT(X[0bin000011110010]=X[0bin001000101101]);
-ASSERT(Y[0bin000011110010]=Y[0bin001000101101]);
-ASSERT(X[0bin000011110011]=X[0bin001001011011]);
-ASSERT(Y[0bin000011110011]=Y[0bin001001011011]);
-ASSERT(X[0bin000011110100]=X[0bin001010001001]);
-ASSERT(Y[0bin000011110100]=Y[0bin001010001001]);
-ASSERT(X[0bin000011110101]=X[0bin001010110111]);
-ASSERT(Y[0bin000011110101]=Y[0bin001010110111]);
-ASSERT(X[0bin000011110110]=X[0bin001011100101]);
-ASSERT(Y[0bin000011110110]=Y[0bin001011100101]);
-ASSERT(X[0bin000011110111]=X[0bin001100010011]);
-ASSERT(Y[0bin000011110111]=Y[0bin001100010011]);
-ASSERT(X[0bin000011111000]=X[0bin001101000001]);
-ASSERT(Y[0bin000011111000]=Y[0bin001101000001]);
-ASSERT(X[0bin000011111001]=X[0bin001101101111]);
-ASSERT(Y[0bin000011111001]=Y[0bin001101101111]);
-ASSERT(X[0bin000011111010]=X[0bin001110011101]);
-ASSERT(Y[0bin000011111010]=Y[0bin001110011101]);
-ASSERT(X[0bin000011111011]=X[0bin001111001011]);
-ASSERT(Y[0bin000011111011]=Y[0bin001111001011]);
-ASSERT(X[0bin000011111100]=X[0bin001111111001]);
-ASSERT(Y[0bin000011111100]=Y[0bin001111111001]);
-ASSERT(X[0bin000011111101]=X[0bin010000100111]);
-ASSERT(Y[0bin000011111101]=Y[0bin010000100111]);
-ASSERT(X[0bin000011111110]=X[0bin010001010101]);
-ASSERT(Y[0bin000011111110]=Y[0bin010001010101]);
-ASSERT(X[0bin000011111111]=X[0bin010010000011]);
-ASSERT(Y[0bin000011111111]=Y[0bin010010000011]);
-ASSERT(X[0bin000100000000]=X[0bin010010110001]);
-ASSERT(Y[0bin000100000000]=Y[0bin010010110001]);
-ASSERT(X[0bin000100000001]=X[0bin010011011111]);
-ASSERT(Y[0bin000100000001]=Y[0bin010011011111]);
-ASSERT(X[0bin000100000010]=X[0bin010100001101]);
-ASSERT(Y[0bin000100000010]=Y[0bin010100001101]);
-ASSERT(X[0bin000100000011]=X[0bin010100111011]);
-ASSERT(Y[0bin000100000011]=Y[0bin010100111011]);
-ASSERT(X[0bin000100000100]=X[0bin010101101001]);
-ASSERT(Y[0bin000100000100]=Y[0bin010101101001]);
-ASSERT(X[0bin000100000101]=X[0bin010110010111]);
-ASSERT(Y[0bin000100000101]=Y[0bin010110010111]);
-ASSERT(X[0bin000100000110]=X[0bin010111000101]);
-ASSERT(Y[0bin000100000110]=Y[0bin010111000101]);
-ASSERT(X[0bin000100000111]=X[0bin010111110011]);
-ASSERT(Y[0bin000100000111]=Y[0bin010111110011]);
-ASSERT(X[0bin000100001000]=X[0bin011000100001]);
-ASSERT(Y[0bin000100001000]=Y[0bin011000100001]);
-ASSERT(X[0bin000100001001]=X[0bin011001001111]);
-ASSERT(Y[0bin000100001001]=Y[0bin011001001111]);
-ASSERT(X[0bin000100001010]=X[0bin011001111101]);
-ASSERT(Y[0bin000100001010]=Y[0bin011001111101]);
-ASSERT(X[0bin000100001011]=X[0bin011010101011]);
-ASSERT(Y[0bin000100001011]=Y[0bin011010101011]);
-ASSERT(X[0bin000100001100]=X[0bin011011011001]);
-ASSERT(Y[0bin000100001100]=Y[0bin011011011001]);
-ASSERT(X[0bin000100001101]=X[0bin011100000111]);
-ASSERT(Y[0bin000100001101]=Y[0bin011100000111]);
-ASSERT(X[0bin000100001110]=X[0bin011100110101]);
-ASSERT(Y[0bin000100001110]=Y[0bin011100110101]);
-ASSERT(X[0bin000100001111]=X[0bin011101100011]);
-ASSERT(Y[0bin000100001111]=Y[0bin011101100011]);
-ASSERT(X[0bin000100010000]=X[0bin011110010001]);
-ASSERT(Y[0bin000100010000]=Y[0bin011110010001]);
-ASSERT(X[0bin000100010001]=X[0bin011110111111]);
-ASSERT(Y[0bin000100010001]=Y[0bin011110111111]);
-ASSERT(X[0bin000100010010]=X[0bin011111101101]);
-ASSERT(Y[0bin000100010010]=Y[0bin011111101101]);
-ASSERT(X[0bin000100010011]=X[0bin100000011011]);
-ASSERT(Y[0bin000100010011]=Y[0bin100000011011]);
-ASSERT(X[0bin000100010100]=X[0bin000000000110]);
-ASSERT(Y[0bin000100010100]=Y[0bin000000000110]);
-ASSERT(X[0bin000100010101]=X[0bin000000110100]);
-ASSERT(Y[0bin000100010101]=Y[0bin000000110100]);
-ASSERT(X[0bin000100010110]=X[0bin000001100010]);
-ASSERT(Y[0bin000100010110]=Y[0bin000001100010]);
-ASSERT(X[0bin000100010111]=X[0bin000010010000]);
-ASSERT(Y[0bin000100010111]=Y[0bin000010010000]);
-ASSERT(X[0bin000100011000]=X[0bin000010111110]);
-ASSERT(Y[0bin000100011000]=Y[0bin000010111110]);
-ASSERT(X[0bin000100011001]=X[0bin000011101100]);
-ASSERT(Y[0bin000100011001]=Y[0bin000011101100]);
-ASSERT(X[0bin000100011010]=X[0bin000100011010]);
-ASSERT(Y[0bin000100011010]=Y[0bin000100011010]);
-ASSERT(X[0bin000100011011]=X[0bin000101001000]);
-ASSERT(Y[0bin000100011011]=Y[0bin000101001000]);
-ASSERT(X[0bin000100011100]=X[0bin000101110110]);
-ASSERT(Y[0bin000100011100]=Y[0bin000101110110]);
-ASSERT(X[0bin000100011101]=X[0bin000110100100]);
-ASSERT(Y[0bin000100011101]=Y[0bin000110100100]);
-ASSERT(X[0bin000100011110]=X[0bin000111010010]);
-ASSERT(Y[0bin000100011110]=Y[0bin000111010010]);
-ASSERT(X[0bin000100011111]=X[0bin001000000000]);
-ASSERT(Y[0bin000100011111]=Y[0bin001000000000]);
-ASSERT(X[0bin000100100000]=X[0bin001000101110]);
-ASSERT(Y[0bin000100100000]=Y[0bin001000101110]);
-ASSERT(X[0bin000100100001]=X[0bin001001011100]);
-ASSERT(Y[0bin000100100001]=Y[0bin001001011100]);
-ASSERT(X[0bin000100100010]=X[0bin001010001010]);
-ASSERT(Y[0bin000100100010]=Y[0bin001010001010]);
-ASSERT(X[0bin000100100011]=X[0bin001010111000]);
-ASSERT(Y[0bin000100100011]=Y[0bin001010111000]);
-ASSERT(X[0bin000100100100]=X[0bin001011100110]);
-ASSERT(Y[0bin000100100100]=Y[0bin001011100110]);
-ASSERT(X[0bin000100100101]=X[0bin001100010100]);
-ASSERT(Y[0bin000100100101]=Y[0bin001100010100]);
-ASSERT(X[0bin000100100110]=X[0bin001101000010]);
-ASSERT(Y[0bin000100100110]=Y[0bin001101000010]);
-ASSERT(X[0bin000100100111]=X[0bin001101110000]);
-ASSERT(Y[0bin000100100111]=Y[0bin001101110000]);
-ASSERT(X[0bin000100101000]=X[0bin001110011110]);
-ASSERT(Y[0bin000100101000]=Y[0bin001110011110]);
-ASSERT(X[0bin000100101001]=X[0bin001111001100]);
-ASSERT(Y[0bin000100101001]=Y[0bin001111001100]);
-ASSERT(X[0bin000100101010]=X[0bin001111111010]);
-ASSERT(Y[0bin000100101010]=Y[0bin001111111010]);
-ASSERT(X[0bin000100101011]=X[0bin010000101000]);
-ASSERT(Y[0bin000100101011]=Y[0bin010000101000]);
-ASSERT(X[0bin000100101100]=X[0bin010001010110]);
-ASSERT(Y[0bin000100101100]=Y[0bin010001010110]);
-ASSERT(X[0bin000100101101]=X[0bin010010000100]);
-ASSERT(Y[0bin000100101101]=Y[0bin010010000100]);
-ASSERT(X[0bin000100101110]=X[0bin010010110010]);
-ASSERT(Y[0bin000100101110]=Y[0bin010010110010]);
-ASSERT(X[0bin000100101111]=X[0bin010011100000]);
-ASSERT(Y[0bin000100101111]=Y[0bin010011100000]);
-ASSERT(X[0bin000100110000]=X[0bin010100001110]);
-ASSERT(Y[0bin000100110000]=Y[0bin010100001110]);
-ASSERT(X[0bin000100110001]=X[0bin010100111100]);
-ASSERT(Y[0bin000100110001]=Y[0bin010100111100]);
-ASSERT(X[0bin000100110010]=X[0bin010101101010]);
-ASSERT(Y[0bin000100110010]=Y[0bin010101101010]);
-ASSERT(X[0bin000100110011]=X[0bin010110011000]);
-ASSERT(Y[0bin000100110011]=Y[0bin010110011000]);
-ASSERT(X[0bin000100110100]=X[0bin010111000110]);
-ASSERT(Y[0bin000100110100]=Y[0bin010111000110]);
-ASSERT(X[0bin000100110101]=X[0bin010111110100]);
-ASSERT(Y[0bin000100110101]=Y[0bin010111110100]);
-ASSERT(X[0bin000100110110]=X[0bin011000100010]);
-ASSERT(Y[0bin000100110110]=Y[0bin011000100010]);
-ASSERT(X[0bin000100110111]=X[0bin011001010000]);
-ASSERT(Y[0bin000100110111]=Y[0bin011001010000]);
-ASSERT(X[0bin000100111000]=X[0bin011001111110]);
-ASSERT(Y[0bin000100111000]=Y[0bin011001111110]);
-ASSERT(X[0bin000100111001]=X[0bin011010101100]);
-ASSERT(Y[0bin000100111001]=Y[0bin011010101100]);
-ASSERT(X[0bin000100111010]=X[0bin011011011010]);
-ASSERT(Y[0bin000100111010]=Y[0bin011011011010]);
-ASSERT(X[0bin000100111011]=X[0bin011100001000]);
-ASSERT(Y[0bin000100111011]=Y[0bin011100001000]);
-ASSERT(X[0bin000100111100]=X[0bin011100110110]);
-ASSERT(Y[0bin000100111100]=Y[0bin011100110110]);
-ASSERT(X[0bin000100111101]=X[0bin011101100100]);
-ASSERT(Y[0bin000100111101]=Y[0bin011101100100]);
-ASSERT(X[0bin000100111110]=X[0bin011110010010]);
-ASSERT(Y[0bin000100111110]=Y[0bin011110010010]);
-ASSERT(X[0bin000100111111]=X[0bin011111000000]);
-ASSERT(Y[0bin000100111111]=Y[0bin011111000000]);
-ASSERT(X[0bin000101000000]=X[0bin011111101110]);
-ASSERT(Y[0bin000101000000]=Y[0bin011111101110]);
-ASSERT(X[0bin000101000001]=X[0bin100000011100]);
-ASSERT(Y[0bin000101000001]=Y[0bin100000011100]);
-ASSERT(X[0bin000101000010]=X[0bin000000000111]);
-ASSERT(Y[0bin000101000010]=Y[0bin000000000111]);
-ASSERT(X[0bin000101000011]=X[0bin000000110101]);
-ASSERT(Y[0bin000101000011]=Y[0bin000000110101]);
-ASSERT(X[0bin000101000100]=X[0bin000001100011]);
-ASSERT(Y[0bin000101000100]=Y[0bin000001100011]);
-ASSERT(X[0bin000101000101]=X[0bin000010010001]);
-ASSERT(Y[0bin000101000101]=Y[0bin000010010001]);
-ASSERT(X[0bin000101000110]=X[0bin000010111111]);
-ASSERT(Y[0bin000101000110]=Y[0bin000010111111]);
-ASSERT(X[0bin000101000111]=X[0bin000011101101]);
-ASSERT(Y[0bin000101000111]=Y[0bin000011101101]);
-ASSERT(X[0bin000101001000]=X[0bin000100011011]);
-ASSERT(Y[0bin000101001000]=Y[0bin000100011011]);
-ASSERT(X[0bin000101001001]=X[0bin000101001001]);
-ASSERT(Y[0bin000101001001]=Y[0bin000101001001]);
-ASSERT(X[0bin000101001010]=X[0bin000101110111]);
-ASSERT(Y[0bin000101001010]=Y[0bin000101110111]);
-ASSERT(X[0bin000101001011]=X[0bin000110100101]);
-ASSERT(Y[0bin000101001011]=Y[0bin000110100101]);
-ASSERT(X[0bin000101001100]=X[0bin000111010011]);
-ASSERT(Y[0bin000101001100]=Y[0bin000111010011]);
-ASSERT(X[0bin000101001101]=X[0bin001000000001]);
-ASSERT(Y[0bin000101001101]=Y[0bin001000000001]);
-ASSERT(X[0bin000101001110]=X[0bin001000101111]);
-ASSERT(Y[0bin000101001110]=Y[0bin001000101111]);
-ASSERT(X[0bin000101001111]=X[0bin001001011101]);
-ASSERT(Y[0bin000101001111]=Y[0bin001001011101]);
-ASSERT(X[0bin000101010000]=X[0bin001010001011]);
-ASSERT(Y[0bin000101010000]=Y[0bin001010001011]);
-ASSERT(X[0bin000101010001]=X[0bin001010111001]);
-ASSERT(Y[0bin000101010001]=Y[0bin001010111001]);
-ASSERT(X[0bin000101010010]=X[0bin001011100111]);
-ASSERT(Y[0bin000101010010]=Y[0bin001011100111]);
-ASSERT(X[0bin000101010011]=X[0bin001100010101]);
-ASSERT(Y[0bin000101010011]=Y[0bin001100010101]);
-ASSERT(X[0bin000101010100]=X[0bin001101000011]);
-ASSERT(Y[0bin000101010100]=Y[0bin001101000011]);
-ASSERT(X[0bin000101010101]=X[0bin001101110001]);
-ASSERT(Y[0bin000101010101]=Y[0bin001101110001]);
-ASSERT(X[0bin000101010110]=X[0bin001110011111]);
-ASSERT(Y[0bin000101010110]=Y[0bin001110011111]);
-ASSERT(X[0bin000101010111]=X[0bin001111001101]);
-ASSERT(Y[0bin000101010111]=Y[0bin001111001101]);
-ASSERT(X[0bin000101011000]=X[0bin001111111011]);
-ASSERT(Y[0bin000101011000]=Y[0bin001111111011]);
-ASSERT(X[0bin000101011001]=X[0bin010000101001]);
-ASSERT(Y[0bin000101011001]=Y[0bin010000101001]);
-ASSERT(X[0bin000101011010]=X[0bin010001010111]);
-ASSERT(Y[0bin000101011010]=Y[0bin010001010111]);
-ASSERT(X[0bin000101011011]=X[0bin010010000101]);
-ASSERT(Y[0bin000101011011]=Y[0bin010010000101]);
-ASSERT(X[0bin000101011100]=X[0bin010010110011]);
-ASSERT(Y[0bin000101011100]=Y[0bin010010110011]);
-ASSERT(X[0bin000101011101]=X[0bin010011100001]);
-ASSERT(Y[0bin000101011101]=Y[0bin010011100001]);
-ASSERT(X[0bin000101011110]=X[0bin010100001111]);
-ASSERT(Y[0bin000101011110]=Y[0bin010100001111]);
-ASSERT(X[0bin000101011111]=X[0bin010100111101]);
-ASSERT(Y[0bin000101011111]=Y[0bin010100111101]);
-ASSERT(X[0bin000101100000]=X[0bin010101101011]);
-ASSERT(Y[0bin000101100000]=Y[0bin010101101011]);
-ASSERT(X[0bin000101100001]=X[0bin010110011001]);
-ASSERT(Y[0bin000101100001]=Y[0bin010110011001]);
-ASSERT(X[0bin000101100010]=X[0bin010111000111]);
-ASSERT(Y[0bin000101100010]=Y[0bin010111000111]);
-ASSERT(X[0bin000101100011]=X[0bin010111110101]);
-ASSERT(Y[0bin000101100011]=Y[0bin010111110101]);
-ASSERT(X[0bin000101100100]=X[0bin011000100011]);
-ASSERT(Y[0bin000101100100]=Y[0bin011000100011]);
-ASSERT(X[0bin000101100101]=X[0bin011001010001]);
-ASSERT(Y[0bin000101100101]=Y[0bin011001010001]);
-ASSERT(X[0bin000101100110]=X[0bin011001111111]);
-ASSERT(Y[0bin000101100110]=Y[0bin011001111111]);
-ASSERT(X[0bin000101100111]=X[0bin011010101101]);
-ASSERT(Y[0bin000101100111]=Y[0bin011010101101]);
-ASSERT(X[0bin000101101000]=X[0bin011011011011]);
-ASSERT(Y[0bin000101101000]=Y[0bin011011011011]);
-ASSERT(X[0bin000101101001]=X[0bin011100001001]);
-ASSERT(Y[0bin000101101001]=Y[0bin011100001001]);
-ASSERT(X[0bin000101101010]=X[0bin011100110111]);
-ASSERT(Y[0bin000101101010]=Y[0bin011100110111]);
-ASSERT(X[0bin000101101011]=X[0bin011101100101]);
-ASSERT(Y[0bin000101101011]=Y[0bin011101100101]);
-ASSERT(X[0bin000101101100]=X[0bin011110010011]);
-ASSERT(Y[0bin000101101100]=Y[0bin011110010011]);
-ASSERT(X[0bin000101101101]=X[0bin011111000001]);
-ASSERT(Y[0bin000101101101]=Y[0bin011111000001]);
-ASSERT(X[0bin000101101110]=X[0bin011111101111]);
-ASSERT(Y[0bin000101101110]=Y[0bin011111101111]);
-ASSERT(X[0bin000101101111]=X[0bin100000011101]);
-ASSERT(Y[0bin000101101111]=Y[0bin100000011101]);
-ASSERT(X[0bin000101110000]=X[0bin000000001000]);
-ASSERT(Y[0bin000101110000]=Y[0bin000000001000]);
-ASSERT(X[0bin000101110001]=X[0bin000000110110]);
-ASSERT(Y[0bin000101110001]=Y[0bin000000110110]);
-ASSERT(X[0bin000101110010]=X[0bin000001100100]);
-ASSERT(Y[0bin000101110010]=Y[0bin000001100100]);
-ASSERT(X[0bin000101110011]=X[0bin000010010010]);
-ASSERT(Y[0bin000101110011]=Y[0bin000010010010]);
-ASSERT(X[0bin000101110100]=X[0bin000011000000]);
-ASSERT(Y[0bin000101110100]=Y[0bin000011000000]);
-ASSERT(X[0bin000101110101]=X[0bin000011101110]);
-ASSERT(Y[0bin000101110101]=Y[0bin000011101110]);
-ASSERT(X[0bin000101110110]=X[0bin000100011100]);
-ASSERT(Y[0bin000101110110]=Y[0bin000100011100]);
-ASSERT(X[0bin000101110111]=X[0bin000101001010]);
-ASSERT(Y[0bin000101110111]=Y[0bin000101001010]);
-ASSERT(X[0bin000101111000]=X[0bin000101111000]);
-ASSERT(Y[0bin000101111000]=Y[0bin000101111000]);
-ASSERT(X[0bin000101111001]=X[0bin000110100110]);
-ASSERT(Y[0bin000101111001]=Y[0bin000110100110]);
-ASSERT(X[0bin000101111010]=X[0bin000111010100]);
-ASSERT(Y[0bin000101111010]=Y[0bin000111010100]);
-ASSERT(X[0bin000101111011]=X[0bin001000000010]);
-ASSERT(Y[0bin000101111011]=Y[0bin001000000010]);
-ASSERT(X[0bin000101111100]=X[0bin001000110000]);
-ASSERT(Y[0bin000101111100]=Y[0bin001000110000]);
-ASSERT(X[0bin000101111101]=X[0bin001001011110]);
-ASSERT(Y[0bin000101111101]=Y[0bin001001011110]);
-ASSERT(X[0bin000101111110]=X[0bin001010001100]);
-ASSERT(Y[0bin000101111110]=Y[0bin001010001100]);
-ASSERT(X[0bin000101111111]=X[0bin001010111010]);
-ASSERT(Y[0bin000101111111]=Y[0bin001010111010]);
-ASSERT(X[0bin000110000000]=X[0bin001011101000]);
-ASSERT(Y[0bin000110000000]=Y[0bin001011101000]);
-ASSERT(X[0bin000110000001]=X[0bin001100010110]);
-ASSERT(Y[0bin000110000001]=Y[0bin001100010110]);
-ASSERT(X[0bin000110000010]=X[0bin001101000100]);
-ASSERT(Y[0bin000110000010]=Y[0bin001101000100]);
-ASSERT(X[0bin000110000011]=X[0bin001101110010]);
-ASSERT(Y[0bin000110000011]=Y[0bin001101110010]);
-ASSERT(X[0bin000110000100]=X[0bin001110100000]);
-ASSERT(Y[0bin000110000100]=Y[0bin001110100000]);
-ASSERT(X[0bin000110000101]=X[0bin001111001110]);
-ASSERT(Y[0bin000110000101]=Y[0bin001111001110]);
-ASSERT(X[0bin000110000110]=X[0bin001111111100]);
-ASSERT(Y[0bin000110000110]=Y[0bin001111111100]);
-ASSERT(X[0bin000110000111]=X[0bin010000101010]);
-ASSERT(Y[0bin000110000111]=Y[0bin010000101010]);
-ASSERT(X[0bin000110001000]=X[0bin010001011000]);
-ASSERT(Y[0bin000110001000]=Y[0bin010001011000]);
-ASSERT(X[0bin000110001001]=X[0bin010010000110]);
-ASSERT(Y[0bin000110001001]=Y[0bin010010000110]);
-ASSERT(X[0bin000110001010]=X[0bin010010110100]);
-ASSERT(Y[0bin000110001010]=Y[0bin010010110100]);
-ASSERT(X[0bin000110001011]=X[0bin010011100010]);
-ASSERT(Y[0bin000110001011]=Y[0bin010011100010]);
-ASSERT(X[0bin000110001100]=X[0bin010100010000]);
-ASSERT(Y[0bin000110001100]=Y[0bin010100010000]);
-ASSERT(X[0bin000110001101]=X[0bin010100111110]);
-ASSERT(Y[0bin000110001101]=Y[0bin010100111110]);
-ASSERT(X[0bin000110001110]=X[0bin010101101100]);
-ASSERT(Y[0bin000110001110]=Y[0bin010101101100]);
-ASSERT(X[0bin000110001111]=X[0bin010110011010]);
-ASSERT(Y[0bin000110001111]=Y[0bin010110011010]);
-ASSERT(X[0bin000110010000]=X[0bin010111001000]);
-ASSERT(Y[0bin000110010000]=Y[0bin010111001000]);
-ASSERT(X[0bin000110010001]=X[0bin010111110110]);
-ASSERT(Y[0bin000110010001]=Y[0bin010111110110]);
-ASSERT(X[0bin000110010010]=X[0bin011000100100]);
-ASSERT(Y[0bin000110010010]=Y[0bin011000100100]);
-ASSERT(X[0bin000110010011]=X[0bin011001010010]);
-ASSERT(Y[0bin000110010011]=Y[0bin011001010010]);
-ASSERT(X[0bin000110010100]=X[0bin011010000000]);
-ASSERT(Y[0bin000110010100]=Y[0bin011010000000]);
-ASSERT(X[0bin000110010101]=X[0bin011010101110]);
-ASSERT(Y[0bin000110010101]=Y[0bin011010101110]);
-ASSERT(X[0bin000110010110]=X[0bin011011011100]);
-ASSERT(Y[0bin000110010110]=Y[0bin011011011100]);
-ASSERT(X[0bin000110010111]=X[0bin011100001010]);
-ASSERT(Y[0bin000110010111]=Y[0bin011100001010]);
-ASSERT(X[0bin000110011000]=X[0bin011100111000]);
-ASSERT(Y[0bin000110011000]=Y[0bin011100111000]);
-ASSERT(X[0bin000110011001]=X[0bin011101100110]);
-ASSERT(Y[0bin000110011001]=Y[0bin011101100110]);
-ASSERT(X[0bin000110011010]=X[0bin011110010100]);
-ASSERT(Y[0bin000110011010]=Y[0bin011110010100]);
-ASSERT(X[0bin000110011011]=X[0bin011111000010]);
-ASSERT(Y[0bin000110011011]=Y[0bin011111000010]);
-ASSERT(X[0bin000110011100]=X[0bin011111110000]);
-ASSERT(Y[0bin000110011100]=Y[0bin011111110000]);
-ASSERT(X[0bin000110011101]=X[0bin100000011110]);
-ASSERT(Y[0bin000110011101]=Y[0bin100000011110]);
-ASSERT(X[0bin000110011110]=X[0bin000000001001]);
-ASSERT(Y[0bin000110011110]=Y[0bin000000001001]);
-ASSERT(X[0bin000110011111]=X[0bin000000110111]);
-ASSERT(Y[0bin000110011111]=Y[0bin000000110111]);
-ASSERT(X[0bin000110100000]=X[0bin000001100101]);
-ASSERT(Y[0bin000110100000]=Y[0bin000001100101]);
-ASSERT(X[0bin000110100001]=X[0bin000010010011]);
-ASSERT(Y[0bin000110100001]=Y[0bin000010010011]);
-ASSERT(X[0bin000110100010]=X[0bin000011000001]);
-ASSERT(Y[0bin000110100010]=Y[0bin000011000001]);
-ASSERT(X[0bin000110100011]=X[0bin000011101111]);
-ASSERT(Y[0bin000110100011]=Y[0bin000011101111]);
-ASSERT(X[0bin000110100100]=X[0bin000100011101]);
-ASSERT(Y[0bin000110100100]=Y[0bin000100011101]);
-ASSERT(X[0bin000110100101]=X[0bin000101001011]);
-ASSERT(Y[0bin000110100101]=Y[0bin000101001011]);
-ASSERT(X[0bin000110100110]=X[0bin000101111001]);
-ASSERT(Y[0bin000110100110]=Y[0bin000101111001]);
-ASSERT(X[0bin000110100111]=X[0bin000110100111]);
-ASSERT(Y[0bin000110100111]=Y[0bin000110100111]);
-ASSERT(X[0bin000110101000]=X[0bin000111010101]);
-ASSERT(Y[0bin000110101000]=Y[0bin000111010101]);
-ASSERT(X[0bin000110101001]=X[0bin001000000011]);
-ASSERT(Y[0bin000110101001]=Y[0bin001000000011]);
-ASSERT(X[0bin000110101010]=X[0bin001000110001]);
-ASSERT(Y[0bin000110101010]=Y[0bin001000110001]);
-ASSERT(X[0bin000110101011]=X[0bin001001011111]);
-ASSERT(Y[0bin000110101011]=Y[0bin001001011111]);
-ASSERT(X[0bin000110101100]=X[0bin001010001101]);
-ASSERT(Y[0bin000110101100]=Y[0bin001010001101]);
-ASSERT(X[0bin000110101101]=X[0bin001010111011]);
-ASSERT(Y[0bin000110101101]=Y[0bin001010111011]);
-ASSERT(X[0bin000110101110]=X[0bin001011101001]);
-ASSERT(Y[0bin000110101110]=Y[0bin001011101001]);
-ASSERT(X[0bin000110101111]=X[0bin001100010111]);
-ASSERT(Y[0bin000110101111]=Y[0bin001100010111]);
-ASSERT(X[0bin000110110000]=X[0bin001101000101]);
-ASSERT(Y[0bin000110110000]=Y[0bin001101000101]);
-ASSERT(X[0bin000110110001]=X[0bin001101110011]);
-ASSERT(Y[0bin000110110001]=Y[0bin001101110011]);
-ASSERT(X[0bin000110110010]=X[0bin001110100001]);
-ASSERT(Y[0bin000110110010]=Y[0bin001110100001]);
-ASSERT(X[0bin000110110011]=X[0bin001111001111]);
-ASSERT(Y[0bin000110110011]=Y[0bin001111001111]);
-ASSERT(X[0bin000110110100]=X[0bin001111111101]);
-ASSERT(Y[0bin000110110100]=Y[0bin001111111101]);
-ASSERT(X[0bin000110110101]=X[0bin010000101011]);
-ASSERT(Y[0bin000110110101]=Y[0bin010000101011]);
-ASSERT(X[0bin000110110110]=X[0bin010001011001]);
-ASSERT(Y[0bin000110110110]=Y[0bin010001011001]);
-ASSERT(X[0bin000110110111]=X[0bin010010000111]);
-ASSERT(Y[0bin000110110111]=Y[0bin010010000111]);
-ASSERT(X[0bin000110111000]=X[0bin010010110101]);
-ASSERT(Y[0bin000110111000]=Y[0bin010010110101]);
-ASSERT(X[0bin000110111001]=X[0bin010011100011]);
-ASSERT(Y[0bin000110111001]=Y[0bin010011100011]);
-ASSERT(X[0bin000110111010]=X[0bin010100010001]);
-ASSERT(Y[0bin000110111010]=Y[0bin010100010001]);
-ASSERT(X[0bin000110111011]=X[0bin010100111111]);
-ASSERT(Y[0bin000110111011]=Y[0bin010100111111]);
-ASSERT(X[0bin000110111100]=X[0bin010101101101]);
-ASSERT(Y[0bin000110111100]=Y[0bin010101101101]);
-ASSERT(X[0bin000110111101]=X[0bin010110011011]);
-ASSERT(Y[0bin000110111101]=Y[0bin010110011011]);
-ASSERT(X[0bin000110111110]=X[0bin010111001001]);
-ASSERT(Y[0bin000110111110]=Y[0bin010111001001]);
-ASSERT(X[0bin000110111111]=X[0bin010111110111]);
-ASSERT(Y[0bin000110111111]=Y[0bin010111110111]);
-ASSERT(X[0bin000111000000]=X[0bin011000100101]);
-ASSERT(Y[0bin000111000000]=Y[0bin011000100101]);
-ASSERT(X[0bin000111000001]=X[0bin011001010011]);
-ASSERT(Y[0bin000111000001]=Y[0bin011001010011]);
-ASSERT(X[0bin000111000010]=X[0bin011010000001]);
-ASSERT(Y[0bin000111000010]=Y[0bin011010000001]);
-ASSERT(X[0bin000111000011]=X[0bin011010101111]);
-ASSERT(Y[0bin000111000011]=Y[0bin011010101111]);
-ASSERT(X[0bin000111000100]=X[0bin011011011101]);
-ASSERT(Y[0bin000111000100]=Y[0bin011011011101]);
-ASSERT(X[0bin000111000101]=X[0bin011100001011]);
-ASSERT(Y[0bin000111000101]=Y[0bin011100001011]);
-ASSERT(X[0bin000111000110]=X[0bin011100111001]);
-ASSERT(Y[0bin000111000110]=Y[0bin011100111001]);
-ASSERT(X[0bin000111000111]=X[0bin011101100111]);
-ASSERT(Y[0bin000111000111]=Y[0bin011101100111]);
-ASSERT(X[0bin000111001000]=X[0bin011110010101]);
-ASSERT(Y[0bin000111001000]=Y[0bin011110010101]);
-ASSERT(X[0bin000111001001]=X[0bin011111000011]);
-ASSERT(Y[0bin000111001001]=Y[0bin011111000011]);
-ASSERT(X[0bin000111001010]=X[0bin011111110001]);
-ASSERT(Y[0bin000111001010]=Y[0bin011111110001]);
-ASSERT(X[0bin000111001011]=X[0bin100000011111]);
-ASSERT(Y[0bin000111001011]=Y[0bin100000011111]);
-ASSERT(X[0bin000111001100]=X[0bin000000001010]);
-ASSERT(Y[0bin000111001100]=Y[0bin000000001010]);
-ASSERT(X[0bin000111001101]=X[0bin000000111000]);
-ASSERT(Y[0bin000111001101]=Y[0bin000000111000]);
-ASSERT(X[0bin000111001110]=X[0bin000001100110]);
-ASSERT(Y[0bin000111001110]=Y[0bin000001100110]);
-ASSERT(X[0bin000111001111]=X[0bin000010010100]);
-ASSERT(Y[0bin000111001111]=Y[0bin000010010100]);
-ASSERT(X[0bin000111010000]=X[0bin000011000010]);
-ASSERT(Y[0bin000111010000]=Y[0bin000011000010]);
-ASSERT(X[0bin000111010001]=X[0bin000011110000]);
-ASSERT(Y[0bin000111010001]=Y[0bin000011110000]);
-ASSERT(X[0bin000111010010]=X[0bin000100011110]);
-ASSERT(Y[0bin000111010010]=Y[0bin000100011110]);
-ASSERT(X[0bin000111010011]=X[0bin000101001100]);
-ASSERT(Y[0bin000111010011]=Y[0bin000101001100]);
-ASSERT(X[0bin000111010100]=X[0bin000101111010]);
-ASSERT(Y[0bin000111010100]=Y[0bin000101111010]);
-ASSERT(X[0bin000111010101]=X[0bin000110101000]);
-ASSERT(Y[0bin000111010101]=Y[0bin000110101000]);
-ASSERT(X[0bin000111010110]=X[0bin000111010110]);
-ASSERT(Y[0bin000111010110]=Y[0bin000111010110]);
-ASSERT(X[0bin000111010111]=X[0bin001000000100]);
-ASSERT(Y[0bin000111010111]=Y[0bin001000000100]);
-ASSERT(X[0bin000111011000]=X[0bin001000110010]);
-ASSERT(Y[0bin000111011000]=Y[0bin001000110010]);
-ASSERT(X[0bin000111011001]=X[0bin001001100000]);
-ASSERT(Y[0bin000111011001]=Y[0bin001001100000]);
-ASSERT(X[0bin000111011010]=X[0bin001010001110]);
-ASSERT(Y[0bin000111011010]=Y[0bin001010001110]);
-ASSERT(X[0bin000111011011]=X[0bin001010111100]);
-ASSERT(Y[0bin000111011011]=Y[0bin001010111100]);
-ASSERT(X[0bin000111011100]=X[0bin001011101010]);
-ASSERT(Y[0bin000111011100]=Y[0bin001011101010]);
-ASSERT(X[0bin000111011101]=X[0bin001100011000]);
-ASSERT(Y[0bin000111011101]=Y[0bin001100011000]);
-ASSERT(X[0bin000111011110]=X[0bin001101000110]);
-ASSERT(Y[0bin000111011110]=Y[0bin001101000110]);
-ASSERT(X[0bin000111011111]=X[0bin001101110100]);
-ASSERT(Y[0bin000111011111]=Y[0bin001101110100]);
-ASSERT(X[0bin000111100000]=X[0bin001110100010]);
-ASSERT(Y[0bin000111100000]=Y[0bin001110100010]);
-ASSERT(X[0bin000111100001]=X[0bin001111010000]);
-ASSERT(Y[0bin000111100001]=Y[0bin001111010000]);
-ASSERT(X[0bin000111100010]=X[0bin001111111110]);
-ASSERT(Y[0bin000111100010]=Y[0bin001111111110]);
-ASSERT(X[0bin000111100011]=X[0bin010000101100]);
-ASSERT(Y[0bin000111100011]=Y[0bin010000101100]);
-ASSERT(X[0bin000111100100]=X[0bin010001011010]);
-ASSERT(Y[0bin000111100100]=Y[0bin010001011010]);
-ASSERT(X[0bin000111100101]=X[0bin010010001000]);
-ASSERT(Y[0bin000111100101]=Y[0bin010010001000]);
-ASSERT(X[0bin000111100110]=X[0bin010010110110]);
-ASSERT(Y[0bin000111100110]=Y[0bin010010110110]);
-ASSERT(X[0bin000111100111]=X[0bin010011100100]);
-ASSERT(Y[0bin000111100111]=Y[0bin010011100100]);
-ASSERT(X[0bin000111101000]=X[0bin010100010010]);
-ASSERT(Y[0bin000111101000]=Y[0bin010100010010]);
-ASSERT(X[0bin000111101001]=X[0bin010101000000]);
-ASSERT(Y[0bin000111101001]=Y[0bin010101000000]);
-ASSERT(X[0bin000111101010]=X[0bin010101101110]);
-ASSERT(Y[0bin000111101010]=Y[0bin010101101110]);
-ASSERT(X[0bin000111101011]=X[0bin010110011100]);
-ASSERT(Y[0bin000111101011]=Y[0bin010110011100]);
-ASSERT(X[0bin000111101100]=X[0bin010111001010]);
-ASSERT(Y[0bin000111101100]=Y[0bin010111001010]);
-ASSERT(X[0bin000111101101]=X[0bin010111111000]);
-ASSERT(Y[0bin000111101101]=Y[0bin010111111000]);
-ASSERT(X[0bin000111101110]=X[0bin011000100110]);
-ASSERT(Y[0bin000111101110]=Y[0bin011000100110]);
-ASSERT(X[0bin000111101111]=X[0bin011001010100]);
-ASSERT(Y[0bin000111101111]=Y[0bin011001010100]);
-ASSERT(X[0bin000111110000]=X[0bin011010000010]);
-ASSERT(Y[0bin000111110000]=Y[0bin011010000010]);
-ASSERT(X[0bin000111110001]=X[0bin011010110000]);
-ASSERT(Y[0bin000111110001]=Y[0bin011010110000]);
-ASSERT(X[0bin000111110010]=X[0bin011011011110]);
-ASSERT(Y[0bin000111110010]=Y[0bin011011011110]);
-ASSERT(X[0bin000111110011]=X[0bin011100001100]);
-ASSERT(Y[0bin000111110011]=Y[0bin011100001100]);
-ASSERT(X[0bin000111110100]=X[0bin011100111010]);
-ASSERT(Y[0bin000111110100]=Y[0bin011100111010]);
-ASSERT(X[0bin000111110101]=X[0bin011101101000]);
-ASSERT(Y[0bin000111110101]=Y[0bin011101101000]);
-ASSERT(X[0bin000111110110]=X[0bin011110010110]);
-ASSERT(Y[0bin000111110110]=Y[0bin011110010110]);
-ASSERT(X[0bin000111110111]=X[0bin011111000100]);
-ASSERT(Y[0bin000111110111]=Y[0bin011111000100]);
-ASSERT(X[0bin000111111000]=X[0bin011111110010]);
-ASSERT(Y[0bin000111111000]=Y[0bin011111110010]);
-ASSERT(X[0bin000111111001]=X[0bin100000100000]);
-ASSERT(Y[0bin000111111001]=Y[0bin100000100000]);
-ASSERT(X[0bin000111111010]=X[0bin000000001011]);
-ASSERT(Y[0bin000111111010]=Y[0bin000000001011]);
-ASSERT(X[0bin000111111011]=X[0bin000000111001]);
-ASSERT(Y[0bin000111111011]=Y[0bin000000111001]);
-ASSERT(X[0bin000111111100]=X[0bin000001100111]);
-ASSERT(Y[0bin000111111100]=Y[0bin000001100111]);
-ASSERT(X[0bin000111111101]=X[0bin000010010101]);
-ASSERT(Y[0bin000111111101]=Y[0bin000010010101]);
-ASSERT(X[0bin000111111110]=X[0bin000011000011]);
-ASSERT(Y[0bin000111111110]=Y[0bin000011000011]);
-ASSERT(X[0bin000111111111]=X[0bin000011110001]);
-ASSERT(Y[0bin000111111111]=Y[0bin000011110001]);
-ASSERT(X[0bin001000000000]=X[0bin000100011111]);
-ASSERT(Y[0bin001000000000]=Y[0bin000100011111]);
-ASSERT(X[0bin001000000001]=X[0bin000101001101]);
-ASSERT(Y[0bin001000000001]=Y[0bin000101001101]);
-ASSERT(X[0bin001000000010]=X[0bin000101111011]);
-ASSERT(Y[0bin001000000010]=Y[0bin000101111011]);
-ASSERT(X[0bin001000000011]=X[0bin000110101001]);
-ASSERT(Y[0bin001000000011]=Y[0bin000110101001]);
-ASSERT(X[0bin001000000100]=X[0bin000111010111]);
-ASSERT(Y[0bin001000000100]=Y[0bin000111010111]);
-ASSERT(X[0bin001000000101]=X[0bin001000000101]);
-ASSERT(Y[0bin001000000101]=Y[0bin001000000101]);
-ASSERT(X[0bin001000000110]=X[0bin001000110011]);
-ASSERT(Y[0bin001000000110]=Y[0bin001000110011]);
-ASSERT(X[0bin001000000111]=X[0bin001001100001]);
-ASSERT(Y[0bin001000000111]=Y[0bin001001100001]);
-ASSERT(X[0bin001000001000]=X[0bin001010001111]);
-ASSERT(Y[0bin001000001000]=Y[0bin001010001111]);
-ASSERT(X[0bin001000001001]=X[0bin001010111101]);
-ASSERT(Y[0bin001000001001]=Y[0bin001010111101]);
-ASSERT(X[0bin001000001010]=X[0bin001011101011]);
-ASSERT(Y[0bin001000001010]=Y[0bin001011101011]);
-ASSERT(X[0bin001000001011]=X[0bin001100011001]);
-ASSERT(Y[0bin001000001011]=Y[0bin001100011001]);
-ASSERT(X[0bin001000001100]=X[0bin001101000111]);
-ASSERT(Y[0bin001000001100]=Y[0bin001101000111]);
-ASSERT(X[0bin001000001101]=X[0bin001101110101]);
-ASSERT(Y[0bin001000001101]=Y[0bin001101110101]);
-ASSERT(X[0bin001000001110]=X[0bin001110100011]);
-ASSERT(Y[0bin001000001110]=Y[0bin001110100011]);
-ASSERT(X[0bin001000001111]=X[0bin001111010001]);
-ASSERT(Y[0bin001000001111]=Y[0bin001111010001]);
-ASSERT(X[0bin001000010000]=X[0bin001111111111]);
-ASSERT(Y[0bin001000010000]=Y[0bin001111111111]);
-ASSERT(X[0bin001000010001]=X[0bin010000101101]);
-ASSERT(Y[0bin001000010001]=Y[0bin010000101101]);
-ASSERT(X[0bin001000010010]=X[0bin010001011011]);
-ASSERT(Y[0bin001000010010]=Y[0bin010001011011]);
-ASSERT(X[0bin001000010011]=X[0bin010010001001]);
-ASSERT(Y[0bin001000010011]=Y[0bin010010001001]);
-ASSERT(X[0bin001000010100]=X[0bin010010110111]);
-ASSERT(Y[0bin001000010100]=Y[0bin010010110111]);
-ASSERT(X[0bin001000010101]=X[0bin010011100101]);
-ASSERT(Y[0bin001000010101]=Y[0bin010011100101]);
-ASSERT(X[0bin001000010110]=X[0bin010100010011]);
-ASSERT(Y[0bin001000010110]=Y[0bin010100010011]);
-ASSERT(X[0bin001000010111]=X[0bin010101000001]);
-ASSERT(Y[0bin001000010111]=Y[0bin010101000001]);
-ASSERT(X[0bin001000011000]=X[0bin010101101111]);
-ASSERT(Y[0bin001000011000]=Y[0bin010101101111]);
-ASSERT(X[0bin001000011001]=X[0bin010110011101]);
-ASSERT(Y[0bin001000011001]=Y[0bin010110011101]);
-ASSERT(X[0bin001000011010]=X[0bin010111001011]);
-ASSERT(Y[0bin001000011010]=Y[0bin010111001011]);
-ASSERT(X[0bin001000011011]=X[0bin010111111001]);
-ASSERT(Y[0bin001000011011]=Y[0bin010111111001]);
-ASSERT(X[0bin001000011100]=X[0bin011000100111]);
-ASSERT(Y[0bin001000011100]=Y[0bin011000100111]);
-ASSERT(X[0bin001000011101]=X[0bin011001010101]);
-ASSERT(Y[0bin001000011101]=Y[0bin011001010101]);
-ASSERT(X[0bin001000011110]=X[0bin011010000011]);
-ASSERT(Y[0bin001000011110]=Y[0bin011010000011]);
-ASSERT(X[0bin001000011111]=X[0bin011010110001]);
-ASSERT(Y[0bin001000011111]=Y[0bin011010110001]);
-ASSERT(X[0bin001000100000]=X[0bin011011011111]);
-ASSERT(Y[0bin001000100000]=Y[0bin011011011111]);
-ASSERT(X[0bin001000100001]=X[0bin011100001101]);
-ASSERT(Y[0bin001000100001]=Y[0bin011100001101]);
-ASSERT(X[0bin001000100010]=X[0bin011100111011]);
-ASSERT(Y[0bin001000100010]=Y[0bin011100111011]);
-ASSERT(X[0bin001000100011]=X[0bin011101101001]);
-ASSERT(Y[0bin001000100011]=Y[0bin011101101001]);
-ASSERT(X[0bin001000100100]=X[0bin011110010111]);
-ASSERT(Y[0bin001000100100]=Y[0bin011110010111]);
-ASSERT(X[0bin001000100101]=X[0bin011111000101]);
-ASSERT(Y[0bin001000100101]=Y[0bin011111000101]);
-ASSERT(X[0bin001000100110]=X[0bin011111110011]);
-ASSERT(Y[0bin001000100110]=Y[0bin011111110011]);
-ASSERT(X[0bin001000100111]=X[0bin100000100001]);
-ASSERT(Y[0bin001000100111]=Y[0bin100000100001]);
-ASSERT(X[0bin001000101000]=X[0bin000000001100]);
-ASSERT(Y[0bin001000101000]=Y[0bin000000001100]);
-ASSERT(X[0bin001000101001]=X[0bin000000111010]);
-ASSERT(Y[0bin001000101001]=Y[0bin000000111010]);
-ASSERT(X[0bin001000101010]=X[0bin000001101000]);
-ASSERT(Y[0bin001000101010]=Y[0bin000001101000]);
-ASSERT(X[0bin001000101011]=X[0bin000010010110]);
-ASSERT(Y[0bin001000101011]=Y[0bin000010010110]);
-ASSERT(X[0bin001000101100]=X[0bin000011000100]);
-ASSERT(Y[0bin001000101100]=Y[0bin000011000100]);
-ASSERT(X[0bin001000101101]=X[0bin000011110010]);
-ASSERT(Y[0bin001000101101]=Y[0bin000011110010]);
-ASSERT(X[0bin001000101110]=X[0bin000100100000]);
-ASSERT(Y[0bin001000101110]=Y[0bin000100100000]);
-ASSERT(X[0bin001000101111]=X[0bin000101001110]);
-ASSERT(Y[0bin001000101111]=Y[0bin000101001110]);
-ASSERT(X[0bin001000110000]=X[0bin000101111100]);
-ASSERT(Y[0bin001000110000]=Y[0bin000101111100]);
-ASSERT(X[0bin001000110001]=X[0bin000110101010]);
-ASSERT(Y[0bin001000110001]=Y[0bin000110101010]);
-ASSERT(X[0bin001000110010]=X[0bin000111011000]);
-ASSERT(Y[0bin001000110010]=Y[0bin000111011000]);
-ASSERT(X[0bin001000110011]=X[0bin001000000110]);
-ASSERT(Y[0bin001000110011]=Y[0bin001000000110]);
-ASSERT(X[0bin001000110100]=X[0bin001000110100]);
-ASSERT(Y[0bin001000110100]=Y[0bin001000110100]);
-ASSERT(X[0bin001000110101]=X[0bin001001100010]);
-ASSERT(Y[0bin001000110101]=Y[0bin001001100010]);
-ASSERT(X[0bin001000110110]=X[0bin001010010000]);
-ASSERT(Y[0bin001000110110]=Y[0bin001010010000]);
-ASSERT(X[0bin001000110111]=X[0bin001010111110]);
-ASSERT(Y[0bin001000110111]=Y[0bin001010111110]);
-ASSERT(X[0bin001000111000]=X[0bin001011101100]);
-ASSERT(Y[0bin001000111000]=Y[0bin001011101100]);
-ASSERT(X[0bin001000111001]=X[0bin001100011010]);
-ASSERT(Y[0bin001000111001]=Y[0bin001100011010]);
-ASSERT(X[0bin001000111010]=X[0bin001101001000]);
-ASSERT(Y[0bin001000111010]=Y[0bin001101001000]);
-ASSERT(X[0bin001000111011]=X[0bin001101110110]);
-ASSERT(Y[0bin001000111011]=Y[0bin001101110110]);
-ASSERT(X[0bin001000111100]=X[0bin001110100100]);
-ASSERT(Y[0bin001000111100]=Y[0bin001110100100]);
-ASSERT(X[0bin001000111101]=X[0bin001111010010]);
-ASSERT(Y[0bin001000111101]=Y[0bin001111010010]);
-ASSERT(X[0bin001000111110]=X[0bin010000000000]);
-ASSERT(Y[0bin001000111110]=Y[0bin010000000000]);
-ASSERT(X[0bin001000111111]=X[0bin010000101110]);
-ASSERT(Y[0bin001000111111]=Y[0bin010000101110]);
-ASSERT(X[0bin001001000000]=X[0bin010001011100]);
-ASSERT(Y[0bin001001000000]=Y[0bin010001011100]);
-ASSERT(X[0bin001001000001]=X[0bin010010001010]);
-ASSERT(Y[0bin001001000001]=Y[0bin010010001010]);
-ASSERT(X[0bin001001000010]=X[0bin010010111000]);
-ASSERT(Y[0bin001001000010]=Y[0bin010010111000]);
-ASSERT(X[0bin001001000011]=X[0bin010011100110]);
-ASSERT(Y[0bin001001000011]=Y[0bin010011100110]);
-ASSERT(X[0bin001001000100]=X[0bin010100010100]);
-ASSERT(Y[0bin001001000100]=Y[0bin010100010100]);
-ASSERT(X[0bin001001000101]=X[0bin010101000010]);
-ASSERT(Y[0bin001001000101]=Y[0bin010101000010]);
-ASSERT(X[0bin001001000110]=X[0bin010101110000]);
-ASSERT(Y[0bin001001000110]=Y[0bin010101110000]);
-ASSERT(X[0bin001001000111]=X[0bin010110011110]);
-ASSERT(Y[0bin001001000111]=Y[0bin010110011110]);
-ASSERT(X[0bin001001001000]=X[0bin010111001100]);
-ASSERT(Y[0bin001001001000]=Y[0bin010111001100]);
-ASSERT(X[0bin001001001001]=X[0bin010111111010]);
-ASSERT(Y[0bin001001001001]=Y[0bin010111111010]);
-ASSERT(X[0bin001001001010]=X[0bin011000101000]);
-ASSERT(Y[0bin001001001010]=Y[0bin011000101000]);
-ASSERT(X[0bin001001001011]=X[0bin011001010110]);
-ASSERT(Y[0bin001001001011]=Y[0bin011001010110]);
-ASSERT(X[0bin001001001100]=X[0bin011010000100]);
-ASSERT(Y[0bin001001001100]=Y[0bin011010000100]);
-ASSERT(X[0bin001001001101]=X[0bin011010110010]);
-ASSERT(Y[0bin001001001101]=Y[0bin011010110010]);
-ASSERT(X[0bin001001001110]=X[0bin011011100000]);
-ASSERT(Y[0bin001001001110]=Y[0bin011011100000]);
-ASSERT(X[0bin001001001111]=X[0bin011100001110]);
-ASSERT(Y[0bin001001001111]=Y[0bin011100001110]);
-ASSERT(X[0bin001001010000]=X[0bin011100111100]);
-ASSERT(Y[0bin001001010000]=Y[0bin011100111100]);
-ASSERT(X[0bin001001010001]=X[0bin011101101010]);
-ASSERT(Y[0bin001001010001]=Y[0bin011101101010]);
-ASSERT(X[0bin001001010010]=X[0bin011110011000]);
-ASSERT(Y[0bin001001010010]=Y[0bin011110011000]);
-ASSERT(X[0bin001001010011]=X[0bin011111000110]);
-ASSERT(Y[0bin001001010011]=Y[0bin011111000110]);
-ASSERT(X[0bin001001010100]=X[0bin011111110100]);
-ASSERT(Y[0bin001001010100]=Y[0bin011111110100]);
-ASSERT(X[0bin001001010101]=X[0bin100000100010]);
-ASSERT(Y[0bin001001010101]=Y[0bin100000100010]);
-ASSERT(X[0bin001001010110]=X[0bin000000001101]);
-ASSERT(Y[0bin001001010110]=Y[0bin000000001101]);
-ASSERT(X[0bin001001010111]=X[0bin000000111011]);
-ASSERT(Y[0bin001001010111]=Y[0bin000000111011]);
-ASSERT(X[0bin001001011000]=X[0bin000001101001]);
-ASSERT(Y[0bin001001011000]=Y[0bin000001101001]);
-ASSERT(X[0bin001001011001]=X[0bin000010010111]);
-ASSERT(Y[0bin001001011001]=Y[0bin000010010111]);
-ASSERT(X[0bin001001011010]=X[0bin000011000101]);
-ASSERT(Y[0bin001001011010]=Y[0bin000011000101]);
-ASSERT(X[0bin001001011011]=X[0bin000011110011]);
-ASSERT(Y[0bin001001011011]=Y[0bin000011110011]);
-ASSERT(X[0bin001001011100]=X[0bin000100100001]);
-ASSERT(Y[0bin001001011100]=Y[0bin000100100001]);
-ASSERT(X[0bin001001011101]=X[0bin000101001111]);
-ASSERT(Y[0bin001001011101]=Y[0bin000101001111]);
-ASSERT(X[0bin001001011110]=X[0bin000101111101]);
-ASSERT(Y[0bin001001011110]=Y[0bin000101111101]);
-ASSERT(X[0bin001001011111]=X[0bin000110101011]);
-ASSERT(Y[0bin001001011111]=Y[0bin000110101011]);
-ASSERT(X[0bin001001100000]=X[0bin000111011001]);
-ASSERT(Y[0bin001001100000]=Y[0bin000111011001]);
-ASSERT(X[0bin001001100001]=X[0bin001000000111]);
-ASSERT(Y[0bin001001100001]=Y[0bin001000000111]);
-ASSERT(X[0bin001001100010]=X[0bin001000110101]);
-ASSERT(Y[0bin001001100010]=Y[0bin001000110101]);
-ASSERT(X[0bin001001100011]=X[0bin001001100011]);
-ASSERT(Y[0bin001001100011]=Y[0bin001001100011]);
-ASSERT(X[0bin001001100100]=X[0bin001010010001]);
-ASSERT(Y[0bin001001100100]=Y[0bin001010010001]);
-ASSERT(X[0bin001001100101]=X[0bin001010111111]);
-ASSERT(Y[0bin001001100101]=Y[0bin001010111111]);
-ASSERT(X[0bin001001100110]=X[0bin001011101101]);
-ASSERT(Y[0bin001001100110]=Y[0bin001011101101]);
-ASSERT(X[0bin001001100111]=X[0bin001100011011]);
-ASSERT(Y[0bin001001100111]=Y[0bin001100011011]);
-ASSERT(X[0bin001001101000]=X[0bin001101001001]);
-ASSERT(Y[0bin001001101000]=Y[0bin001101001001]);
-ASSERT(X[0bin001001101001]=X[0bin001101110111]);
-ASSERT(Y[0bin001001101001]=Y[0bin001101110111]);
-ASSERT(X[0bin001001101010]=X[0bin001110100101]);
-ASSERT(Y[0bin001001101010]=Y[0bin001110100101]);
-ASSERT(X[0bin001001101011]=X[0bin001111010011]);
-ASSERT(Y[0bin001001101011]=Y[0bin001111010011]);
-ASSERT(X[0bin001001101100]=X[0bin010000000001]);
-ASSERT(Y[0bin001001101100]=Y[0bin010000000001]);
-ASSERT(X[0bin001001101101]=X[0bin010000101111]);
-ASSERT(Y[0bin001001101101]=Y[0bin010000101111]);
-ASSERT(X[0bin001001101110]=X[0bin010001011101]);
-ASSERT(Y[0bin001001101110]=Y[0bin010001011101]);
-ASSERT(X[0bin001001101111]=X[0bin010010001011]);
-ASSERT(Y[0bin001001101111]=Y[0bin010010001011]);
-ASSERT(X[0bin001001110000]=X[0bin010010111001]);
-ASSERT(Y[0bin001001110000]=Y[0bin010010111001]);
-ASSERT(X[0bin001001110001]=X[0bin010011100111]);
-ASSERT(Y[0bin001001110001]=Y[0bin010011100111]);
-ASSERT(X[0bin001001110010]=X[0bin010100010101]);
-ASSERT(Y[0bin001001110010]=Y[0bin010100010101]);
-ASSERT(X[0bin001001110011]=X[0bin010101000011]);
-ASSERT(Y[0bin001001110011]=Y[0bin010101000011]);
-ASSERT(X[0bin001001110100]=X[0bin010101110001]);
-ASSERT(Y[0bin001001110100]=Y[0bin010101110001]);
-ASSERT(X[0bin001001110101]=X[0bin010110011111]);
-ASSERT(Y[0bin001001110101]=Y[0bin010110011111]);
-ASSERT(X[0bin001001110110]=X[0bin010111001101]);
-ASSERT(Y[0bin001001110110]=Y[0bin010111001101]);
-ASSERT(X[0bin001001110111]=X[0bin010111111011]);
-ASSERT(Y[0bin001001110111]=Y[0bin010111111011]);
-ASSERT(X[0bin001001111000]=X[0bin011000101001]);
-ASSERT(Y[0bin001001111000]=Y[0bin011000101001]);
-ASSERT(X[0bin001001111001]=X[0bin011001010111]);
-ASSERT(Y[0bin001001111001]=Y[0bin011001010111]);
-ASSERT(X[0bin001001111010]=X[0bin011010000101]);
-ASSERT(Y[0bin001001111010]=Y[0bin011010000101]);
-ASSERT(X[0bin001001111011]=X[0bin011010110011]);
-ASSERT(Y[0bin001001111011]=Y[0bin011010110011]);
-ASSERT(X[0bin001001111100]=X[0bin011011100001]);
-ASSERT(Y[0bin001001111100]=Y[0bin011011100001]);
-ASSERT(X[0bin001001111101]=X[0bin011100001111]);
-ASSERT(Y[0bin001001111101]=Y[0bin011100001111]);
-ASSERT(X[0bin001001111110]=X[0bin011100111101]);
-ASSERT(Y[0bin001001111110]=Y[0bin011100111101]);
-ASSERT(X[0bin001001111111]=X[0bin011101101011]);
-ASSERT(Y[0bin001001111111]=Y[0bin011101101011]);
-ASSERT(X[0bin001010000000]=X[0bin011110011001]);
-ASSERT(Y[0bin001010000000]=Y[0bin011110011001]);
-ASSERT(X[0bin001010000001]=X[0bin011111000111]);
-ASSERT(Y[0bin001010000001]=Y[0bin011111000111]);
-ASSERT(X[0bin001010000010]=X[0bin011111110101]);
-ASSERT(Y[0bin001010000010]=Y[0bin011111110101]);
-ASSERT(X[0bin001010000011]=X[0bin100000100011]);
-ASSERT(Y[0bin001010000011]=Y[0bin100000100011]);
-ASSERT(X[0bin001010000100]=X[0bin000000001110]);
-ASSERT(Y[0bin001010000100]=Y[0bin000000001110]);
-ASSERT(X[0bin001010000101]=X[0bin000000111100]);
-ASSERT(Y[0bin001010000101]=Y[0bin000000111100]);
-ASSERT(X[0bin001010000110]=X[0bin000001101010]);
-ASSERT(Y[0bin001010000110]=Y[0bin000001101010]);
-ASSERT(X[0bin001010000111]=X[0bin000010011000]);
-ASSERT(Y[0bin001010000111]=Y[0bin000010011000]);
-ASSERT(X[0bin001010001000]=X[0bin000011000110]);
-ASSERT(Y[0bin001010001000]=Y[0bin000011000110]);
-ASSERT(X[0bin001010001001]=X[0bin000011110100]);
-ASSERT(Y[0bin001010001001]=Y[0bin000011110100]);
-ASSERT(X[0bin001010001010]=X[0bin000100100010]);
-ASSERT(Y[0bin001010001010]=Y[0bin000100100010]);
-ASSERT(X[0bin001010001011]=X[0bin000101010000]);
-ASSERT(Y[0bin001010001011]=Y[0bin000101010000]);
-ASSERT(X[0bin001010001100]=X[0bin000101111110]);
-ASSERT(Y[0bin001010001100]=Y[0bin000101111110]);
-ASSERT(X[0bin001010001101]=X[0bin000110101100]);
-ASSERT(Y[0bin001010001101]=Y[0bin000110101100]);
-ASSERT(X[0bin001010001110]=X[0bin000111011010]);
-ASSERT(Y[0bin001010001110]=Y[0bin000111011010]);
-ASSERT(X[0bin001010001111]=X[0bin001000001000]);
-ASSERT(Y[0bin001010001111]=Y[0bin001000001000]);
-ASSERT(X[0bin001010010000]=X[0bin001000110110]);
-ASSERT(Y[0bin001010010000]=Y[0bin001000110110]);
-ASSERT(X[0bin001010010001]=X[0bin001001100100]);
-ASSERT(Y[0bin001010010001]=Y[0bin001001100100]);
-ASSERT(X[0bin001010010010]=X[0bin001010010010]);
-ASSERT(Y[0bin001010010010]=Y[0bin001010010010]);
-ASSERT(X[0bin001010010011]=X[0bin001011000000]);
-ASSERT(Y[0bin001010010011]=Y[0bin001011000000]);
-ASSERT(X[0bin001010010100]=X[0bin001011101110]);
-ASSERT(Y[0bin001010010100]=Y[0bin001011101110]);
-ASSERT(X[0bin001010010101]=X[0bin001100011100]);
-ASSERT(Y[0bin001010010101]=Y[0bin001100011100]);
-ASSERT(X[0bin001010010110]=X[0bin001101001010]);
-ASSERT(Y[0bin001010010110]=Y[0bin001101001010]);
-ASSERT(X[0bin001010010111]=X[0bin001101111000]);
-ASSERT(Y[0bin001010010111]=Y[0bin001101111000]);
-ASSERT(X[0bin001010011000]=X[0bin001110100110]);
-ASSERT(Y[0bin001010011000]=Y[0bin001110100110]);
-ASSERT(X[0bin001010011001]=X[0bin001111010100]);
-ASSERT(Y[0bin001010011001]=Y[0bin001111010100]);
-ASSERT(X[0bin001010011010]=X[0bin010000000010]);
-ASSERT(Y[0bin001010011010]=Y[0bin010000000010]);
-ASSERT(X[0bin001010011011]=X[0bin010000110000]);
-ASSERT(Y[0bin001010011011]=Y[0bin010000110000]);
-ASSERT(X[0bin001010011100]=X[0bin010001011110]);
-ASSERT(Y[0bin001010011100]=Y[0bin010001011110]);
-ASSERT(X[0bin001010011101]=X[0bin010010001100]);
-ASSERT(Y[0bin001010011101]=Y[0bin010010001100]);
-ASSERT(X[0bin001010011110]=X[0bin010010111010]);
-ASSERT(Y[0bin001010011110]=Y[0bin010010111010]);
-ASSERT(X[0bin001010011111]=X[0bin010011101000]);
-ASSERT(Y[0bin001010011111]=Y[0bin010011101000]);
-ASSERT(X[0bin001010100000]=X[0bin010100010110]);
-ASSERT(Y[0bin001010100000]=Y[0bin010100010110]);
-ASSERT(X[0bin001010100001]=X[0bin010101000100]);
-ASSERT(Y[0bin001010100001]=Y[0bin010101000100]);
-ASSERT(X[0bin001010100010]=X[0bin010101110010]);
-ASSERT(Y[0bin001010100010]=Y[0bin010101110010]);
-ASSERT(X[0bin001010100011]=X[0bin010110100000]);
-ASSERT(Y[0bin001010100011]=Y[0bin010110100000]);
-ASSERT(X[0bin001010100100]=X[0bin010111001110]);
-ASSERT(Y[0bin001010100100]=Y[0bin010111001110]);
-ASSERT(X[0bin001010100101]=X[0bin010111111100]);
-ASSERT(Y[0bin001010100101]=Y[0bin010111111100]);
-ASSERT(X[0bin001010100110]=X[0bin011000101010]);
-ASSERT(Y[0bin001010100110]=Y[0bin011000101010]);
-ASSERT(X[0bin001010100111]=X[0bin011001011000]);
-ASSERT(Y[0bin001010100111]=Y[0bin011001011000]);
-ASSERT(X[0bin001010101000]=X[0bin011010000110]);
-ASSERT(Y[0bin001010101000]=Y[0bin011010000110]);
-ASSERT(X[0bin001010101001]=X[0bin011010110100]);
-ASSERT(Y[0bin001010101001]=Y[0bin011010110100]);
-ASSERT(X[0bin001010101010]=X[0bin011011100010]);
-ASSERT(Y[0bin001010101010]=Y[0bin011011100010]);
-ASSERT(X[0bin001010101011]=X[0bin011100010000]);
-ASSERT(Y[0bin001010101011]=Y[0bin011100010000]);
-ASSERT(X[0bin001010101100]=X[0bin011100111110]);
-ASSERT(Y[0bin001010101100]=Y[0bin011100111110]);
-ASSERT(X[0bin001010101101]=X[0bin011101101100]);
-ASSERT(Y[0bin001010101101]=Y[0bin011101101100]);
-ASSERT(X[0bin001010101110]=X[0bin011110011010]);
-ASSERT(Y[0bin001010101110]=Y[0bin011110011010]);
-ASSERT(X[0bin001010101111]=X[0bin011111001000]);
-ASSERT(Y[0bin001010101111]=Y[0bin011111001000]);
-ASSERT(X[0bin001010110000]=X[0bin011111110110]);
-ASSERT(Y[0bin001010110000]=Y[0bin011111110110]);
-ASSERT(X[0bin001010110001]=X[0bin100000100100]);
-ASSERT(Y[0bin001010110001]=Y[0bin100000100100]);
-ASSERT(X[0bin001010110010]=X[0bin000000001111]);
-ASSERT(Y[0bin001010110010]=Y[0bin000000001111]);
-ASSERT(X[0bin001010110011]=X[0bin000000111101]);
-ASSERT(Y[0bin001010110011]=Y[0bin000000111101]);
-ASSERT(X[0bin001010110100]=X[0bin000001101011]);
-ASSERT(Y[0bin001010110100]=Y[0bin000001101011]);
-ASSERT(X[0bin001010110101]=X[0bin000010011001]);
-ASSERT(Y[0bin001010110101]=Y[0bin000010011001]);
-ASSERT(X[0bin001010110110]=X[0bin000011000111]);
-ASSERT(Y[0bin001010110110]=Y[0bin000011000111]);
-ASSERT(X[0bin001010110111]=X[0bin000011110101]);
-ASSERT(Y[0bin001010110111]=Y[0bin000011110101]);
-ASSERT(X[0bin001010111000]=X[0bin000100100011]);
-ASSERT(Y[0bin001010111000]=Y[0bin000100100011]);
-ASSERT(X[0bin001010111001]=X[0bin000101010001]);
-ASSERT(Y[0bin001010111001]=Y[0bin000101010001]);
-ASSERT(X[0bin001010111010]=X[0bin000101111111]);
-ASSERT(Y[0bin001010111010]=Y[0bin000101111111]);
-ASSERT(X[0bin001010111011]=X[0bin000110101101]);
-ASSERT(Y[0bin001010111011]=Y[0bin000110101101]);
-ASSERT(X[0bin001010111100]=X[0bin000111011011]);
-ASSERT(Y[0bin001010111100]=Y[0bin000111011011]);
-ASSERT(X[0bin001010111101]=X[0bin001000001001]);
-ASSERT(Y[0bin001010111101]=Y[0bin001000001001]);
-ASSERT(X[0bin001010111110]=X[0bin001000110111]);
-ASSERT(Y[0bin001010111110]=Y[0bin001000110111]);
-ASSERT(X[0bin001010111111]=X[0bin001001100101]);
-ASSERT(Y[0bin001010111111]=Y[0bin001001100101]);
-ASSERT(X[0bin001011000000]=X[0bin001010010011]);
-ASSERT(Y[0bin001011000000]=Y[0bin001010010011]);
-ASSERT(X[0bin001011000001]=X[0bin001011000001]);
-ASSERT(Y[0bin001011000001]=Y[0bin001011000001]);
-ASSERT(X[0bin001011000010]=X[0bin001011101111]);
-ASSERT(Y[0bin001011000010]=Y[0bin001011101111]);
-ASSERT(X[0bin001011000011]=X[0bin001100011101]);
-ASSERT(Y[0bin001011000011]=Y[0bin001100011101]);
-ASSERT(X[0bin001011000100]=X[0bin001101001011]);
-ASSERT(Y[0bin001011000100]=Y[0bin001101001011]);
-ASSERT(X[0bin001011000101]=X[0bin001101111001]);
-ASSERT(Y[0bin001011000101]=Y[0bin001101111001]);
-ASSERT(X[0bin001011000110]=X[0bin001110100111]);
-ASSERT(Y[0bin001011000110]=Y[0bin001110100111]);
-ASSERT(X[0bin001011000111]=X[0bin001111010101]);
-ASSERT(Y[0bin001011000111]=Y[0bin001111010101]);
-ASSERT(X[0bin001011001000]=X[0bin010000000011]);
-ASSERT(Y[0bin001011001000]=Y[0bin010000000011]);
-ASSERT(X[0bin001011001001]=X[0bin010000110001]);
-ASSERT(Y[0bin001011001001]=Y[0bin010000110001]);
-ASSERT(X[0bin001011001010]=X[0bin010001011111]);
-ASSERT(Y[0bin001011001010]=Y[0bin010001011111]);
-ASSERT(X[0bin001011001011]=X[0bin010010001101]);
-ASSERT(Y[0bin001011001011]=Y[0bin010010001101]);
-ASSERT(X[0bin001011001100]=X[0bin010010111011]);
-ASSERT(Y[0bin001011001100]=Y[0bin010010111011]);
-ASSERT(X[0bin001011001101]=X[0bin010011101001]);
-ASSERT(Y[0bin001011001101]=Y[0bin010011101001]);
-ASSERT(X[0bin001011001110]=X[0bin010100010111]);
-ASSERT(Y[0bin001011001110]=Y[0bin010100010111]);
-ASSERT(X[0bin001011001111]=X[0bin010101000101]);
-ASSERT(Y[0bin001011001111]=Y[0bin010101000101]);
-ASSERT(X[0bin001011010000]=X[0bin010101110011]);
-ASSERT(Y[0bin001011010000]=Y[0bin010101110011]);
-ASSERT(X[0bin001011010001]=X[0bin010110100001]);
-ASSERT(Y[0bin001011010001]=Y[0bin010110100001]);
-ASSERT(X[0bin001011010010]=X[0bin010111001111]);
-ASSERT(Y[0bin001011010010]=Y[0bin010111001111]);
-ASSERT(X[0bin001011010011]=X[0bin010111111101]);
-ASSERT(Y[0bin001011010011]=Y[0bin010111111101]);
-ASSERT(X[0bin001011010100]=X[0bin011000101011]);
-ASSERT(Y[0bin001011010100]=Y[0bin011000101011]);
-ASSERT(X[0bin001011010101]=X[0bin011001011001]);
-ASSERT(Y[0bin001011010101]=Y[0bin011001011001]);
-ASSERT(X[0bin001011010110]=X[0bin011010000111]);
-ASSERT(Y[0bin001011010110]=Y[0bin011010000111]);
-ASSERT(X[0bin001011010111]=X[0bin011010110101]);
-ASSERT(Y[0bin001011010111]=Y[0bin011010110101]);
-ASSERT(X[0bin001011011000]=X[0bin011011100011]);
-ASSERT(Y[0bin001011011000]=Y[0bin011011100011]);
-ASSERT(X[0bin001011011001]=X[0bin011100010001]);
-ASSERT(Y[0bin001011011001]=Y[0bin011100010001]);
-ASSERT(X[0bin001011011010]=X[0bin011100111111]);
-ASSERT(Y[0bin001011011010]=Y[0bin011100111111]);
-ASSERT(X[0bin001011011011]=X[0bin011101101101]);
-ASSERT(Y[0bin001011011011]=Y[0bin011101101101]);
-ASSERT(X[0bin001011011100]=X[0bin011110011011]);
-ASSERT(Y[0bin001011011100]=Y[0bin011110011011]);
-ASSERT(X[0bin001011011101]=X[0bin011111001001]);
-ASSERT(Y[0bin001011011101]=Y[0bin011111001001]);
-ASSERT(X[0bin001011011110]=X[0bin011111110111]);
-ASSERT(Y[0bin001011011110]=Y[0bin011111110111]);
-ASSERT(X[0bin001011011111]=X[0bin100000100101]);
-ASSERT(Y[0bin001011011111]=Y[0bin100000100101]);
-ASSERT(X[0bin001011100000]=X[0bin000000010000]);
-ASSERT(Y[0bin001011100000]=Y[0bin000000010000]);
-ASSERT(X[0bin001011100001]=X[0bin000000111110]);
-ASSERT(Y[0bin001011100001]=Y[0bin000000111110]);
-ASSERT(X[0bin001011100010]=X[0bin000001101100]);
-ASSERT(Y[0bin001011100010]=Y[0bin000001101100]);
-ASSERT(X[0bin001011100011]=X[0bin000010011010]);
-ASSERT(Y[0bin001011100011]=Y[0bin000010011010]);
-ASSERT(X[0bin001011100100]=X[0bin000011001000]);
-ASSERT(Y[0bin001011100100]=Y[0bin000011001000]);
-ASSERT(X[0bin001011100101]=X[0bin000011110110]);
-ASSERT(Y[0bin001011100101]=Y[0bin000011110110]);
-ASSERT(X[0bin001011100110]=X[0bin000100100100]);
-ASSERT(Y[0bin001011100110]=Y[0bin000100100100]);
-ASSERT(X[0bin001011100111]=X[0bin000101010010]);
-ASSERT(Y[0bin001011100111]=Y[0bin000101010010]);
-ASSERT(X[0bin001011101000]=X[0bin000110000000]);
-ASSERT(Y[0bin001011101000]=Y[0bin000110000000]);
-ASSERT(X[0bin001011101001]=X[0bin000110101110]);
-ASSERT(Y[0bin001011101001]=Y[0bin000110101110]);
-ASSERT(X[0bin001011101010]=X[0bin000111011100]);
-ASSERT(Y[0bin001011101010]=Y[0bin000111011100]);
-ASSERT(X[0bin001011101011]=X[0bin001000001010]);
-ASSERT(Y[0bin001011101011]=Y[0bin001000001010]);
-ASSERT(X[0bin001011101100]=X[0bin001000111000]);
-ASSERT(Y[0bin001011101100]=Y[0bin001000111000]);
-ASSERT(X[0bin001011101101]=X[0bin001001100110]);
-ASSERT(Y[0bin001011101101]=Y[0bin001001100110]);
-ASSERT(X[0bin001011101110]=X[0bin001010010100]);
-ASSERT(Y[0bin001011101110]=Y[0bin001010010100]);
-ASSERT(X[0bin001011101111]=X[0bin001011000010]);
-ASSERT(Y[0bin001011101111]=Y[0bin001011000010]);
-ASSERT(X[0bin001011110000]=X[0bin001011110000]);
-ASSERT(Y[0bin001011110000]=Y[0bin001011110000]);
-ASSERT(X[0bin001011110001]=X[0bin001100011110]);
-ASSERT(Y[0bin001011110001]=Y[0bin001100011110]);
-ASSERT(X[0bin001011110010]=X[0bin001101001100]);
-ASSERT(Y[0bin001011110010]=Y[0bin001101001100]);
-ASSERT(X[0bin001011110011]=X[0bin001101111010]);
-ASSERT(Y[0bin001011110011]=Y[0bin001101111010]);
-ASSERT(X[0bin001011110100]=X[0bin001110101000]);
-ASSERT(Y[0bin001011110100]=Y[0bin001110101000]);
-ASSERT(X[0bin001011110101]=X[0bin001111010110]);
-ASSERT(Y[0bin001011110101]=Y[0bin001111010110]);
-ASSERT(X[0bin001011110110]=X[0bin010000000100]);
-ASSERT(Y[0bin001011110110]=Y[0bin010000000100]);
-ASSERT(X[0bin001011110111]=X[0bin010000110010]);
-ASSERT(Y[0bin001011110111]=Y[0bin010000110010]);
-ASSERT(X[0bin001011111000]=X[0bin010001100000]);
-ASSERT(Y[0bin001011111000]=Y[0bin010001100000]);
-ASSERT(X[0bin001011111001]=X[0bin010010001110]);
-ASSERT(Y[0bin001011111001]=Y[0bin010010001110]);
-ASSERT(X[0bin001011111010]=X[0bin010010111100]);
-ASSERT(Y[0bin001011111010]=Y[0bin010010111100]);
-ASSERT(X[0bin001011111011]=X[0bin010011101010]);
-ASSERT(Y[0bin001011111011]=Y[0bin010011101010]);
-ASSERT(X[0bin001011111100]=X[0bin010100011000]);
-ASSERT(Y[0bin001011111100]=Y[0bin010100011000]);
-ASSERT(X[0bin001011111101]=X[0bin010101000110]);
-ASSERT(Y[0bin001011111101]=Y[0bin010101000110]);
-ASSERT(X[0bin001011111110]=X[0bin010101110100]);
-ASSERT(Y[0bin001011111110]=Y[0bin010101110100]);
-ASSERT(X[0bin001011111111]=X[0bin010110100010]);
-ASSERT(Y[0bin001011111111]=Y[0bin010110100010]);
-ASSERT(X[0bin001100000000]=X[0bin010111010000]);
-ASSERT(Y[0bin001100000000]=Y[0bin010111010000]);
-ASSERT(X[0bin001100000001]=X[0bin010111111110]);
-ASSERT(Y[0bin001100000001]=Y[0bin010111111110]);
-ASSERT(X[0bin001100000010]=X[0bin011000101100]);
-ASSERT(Y[0bin001100000010]=Y[0bin011000101100]);
-ASSERT(X[0bin001100000011]=X[0bin011001011010]);
-ASSERT(Y[0bin001100000011]=Y[0bin011001011010]);
-ASSERT(X[0bin001100000100]=X[0bin011010001000]);
-ASSERT(Y[0bin001100000100]=Y[0bin011010001000]);
-ASSERT(X[0bin001100000101]=X[0bin011010110110]);
-ASSERT(Y[0bin001100000101]=Y[0bin011010110110]);
-ASSERT(X[0bin001100000110]=X[0bin011011100100]);
-ASSERT(Y[0bin001100000110]=Y[0bin011011100100]);
-ASSERT(X[0bin001100000111]=X[0bin011100010010]);
-ASSERT(Y[0bin001100000111]=Y[0bin011100010010]);
-ASSERT(X[0bin001100001000]=X[0bin011101000000]);
-ASSERT(Y[0bin001100001000]=Y[0bin011101000000]);
-ASSERT(X[0bin001100001001]=X[0bin011101101110]);
-ASSERT(Y[0bin001100001001]=Y[0bin011101101110]);
-ASSERT(X[0bin001100001010]=X[0bin011110011100]);
-ASSERT(Y[0bin001100001010]=Y[0bin011110011100]);
-ASSERT(X[0bin001100001011]=X[0bin011111001010]);
-ASSERT(Y[0bin001100001011]=Y[0bin011111001010]);
-ASSERT(X[0bin001100001100]=X[0bin011111111000]);
-ASSERT(Y[0bin001100001100]=Y[0bin011111111000]);
-ASSERT(X[0bin001100001101]=X[0bin100000100110]);
-ASSERT(Y[0bin001100001101]=Y[0bin100000100110]);
-ASSERT(X[0bin001100001110]=X[0bin000000010001]);
-ASSERT(Y[0bin001100001110]=Y[0bin000000010001]);
-ASSERT(X[0bin001100001111]=X[0bin000000111111]);
-ASSERT(Y[0bin001100001111]=Y[0bin000000111111]);
-ASSERT(X[0bin001100010000]=X[0bin000001101101]);
-ASSERT(Y[0bin001100010000]=Y[0bin000001101101]);
-ASSERT(X[0bin001100010001]=X[0bin000010011011]);
-ASSERT(Y[0bin001100010001]=Y[0bin000010011011]);
-ASSERT(X[0bin001100010010]=X[0bin000011001001]);
-ASSERT(Y[0bin001100010010]=Y[0bin000011001001]);
-ASSERT(X[0bin001100010011]=X[0bin000011110111]);
-ASSERT(Y[0bin001100010011]=Y[0bin000011110111]);
-ASSERT(X[0bin001100010100]=X[0bin000100100101]);
-ASSERT(Y[0bin001100010100]=Y[0bin000100100101]);
-ASSERT(X[0bin001100010101]=X[0bin000101010011]);
-ASSERT(Y[0bin001100010101]=Y[0bin000101010011]);
-ASSERT(X[0bin001100010110]=X[0bin000110000001]);
-ASSERT(Y[0bin001100010110]=Y[0bin000110000001]);
-ASSERT(X[0bin001100010111]=X[0bin000110101111]);
-ASSERT(Y[0bin001100010111]=Y[0bin000110101111]);
-ASSERT(X[0bin001100011000]=X[0bin000111011101]);
-ASSERT(Y[0bin001100011000]=Y[0bin000111011101]);
-ASSERT(X[0bin001100011001]=X[0bin001000001011]);
-ASSERT(Y[0bin001100011001]=Y[0bin001000001011]);
-ASSERT(X[0bin001100011010]=X[0bin001000111001]);
-ASSERT(Y[0bin001100011010]=Y[0bin001000111001]);
-ASSERT(X[0bin001100011011]=X[0bin001001100111]);
-ASSERT(Y[0bin001100011011]=Y[0bin001001100111]);
-ASSERT(X[0bin001100011100]=X[0bin001010010101]);
-ASSERT(Y[0bin001100011100]=Y[0bin001010010101]);
-ASSERT(X[0bin001100011101]=X[0bin001011000011]);
-ASSERT(Y[0bin001100011101]=Y[0bin001011000011]);
-ASSERT(X[0bin001100011110]=X[0bin001011110001]);
-ASSERT(Y[0bin001100011110]=Y[0bin001011110001]);
-ASSERT(X[0bin001100011111]=X[0bin001100011111]);
-ASSERT(Y[0bin001100011111]=Y[0bin001100011111]);
-ASSERT(X[0bin001100100000]=X[0bin001101001101]);
-ASSERT(Y[0bin001100100000]=Y[0bin001101001101]);
-ASSERT(X[0bin001100100001]=X[0bin001101111011]);
-ASSERT(Y[0bin001100100001]=Y[0bin001101111011]);
-ASSERT(X[0bin001100100010]=X[0bin001110101001]);
-ASSERT(Y[0bin001100100010]=Y[0bin001110101001]);
-ASSERT(X[0bin001100100011]=X[0bin001111010111]);
-ASSERT(Y[0bin001100100011]=Y[0bin001111010111]);
-ASSERT(X[0bin001100100100]=X[0bin010000000101]);
-ASSERT(Y[0bin001100100100]=Y[0bin010000000101]);
-ASSERT(X[0bin001100100101]=X[0bin010000110011]);
-ASSERT(Y[0bin001100100101]=Y[0bin010000110011]);
-ASSERT(X[0bin001100100110]=X[0bin010001100001]);
-ASSERT(Y[0bin001100100110]=Y[0bin010001100001]);
-ASSERT(X[0bin001100100111]=X[0bin010010001111]);
-ASSERT(Y[0bin001100100111]=Y[0bin010010001111]);
-ASSERT(X[0bin001100101000]=X[0bin010010111101]);
-ASSERT(Y[0bin001100101000]=Y[0bin010010111101]);
-ASSERT(X[0bin001100101001]=X[0bin010011101011]);
-ASSERT(Y[0bin001100101001]=Y[0bin010011101011]);
-ASSERT(X[0bin001100101010]=X[0bin010100011001]);
-ASSERT(Y[0bin001100101010]=Y[0bin010100011001]);
-ASSERT(X[0bin001100101011]=X[0bin010101000111]);
-ASSERT(Y[0bin001100101011]=Y[0bin010101000111]);
-ASSERT(X[0bin001100101100]=X[0bin010101110101]);
-ASSERT(Y[0bin001100101100]=Y[0bin010101110101]);
-ASSERT(X[0bin001100101101]=X[0bin010110100011]);
-ASSERT(Y[0bin001100101101]=Y[0bin010110100011]);
-ASSERT(X[0bin001100101110]=X[0bin010111010001]);
-ASSERT(Y[0bin001100101110]=Y[0bin010111010001]);
-ASSERT(X[0bin001100101111]=X[0bin010111111111]);
-ASSERT(Y[0bin001100101111]=Y[0bin010111111111]);
-ASSERT(X[0bin001100110000]=X[0bin011000101101]);
-ASSERT(Y[0bin001100110000]=Y[0bin011000101101]);
-ASSERT(X[0bin001100110001]=X[0bin011001011011]);
-ASSERT(Y[0bin001100110001]=Y[0bin011001011011]);
-ASSERT(X[0bin001100110010]=X[0bin011010001001]);
-ASSERT(Y[0bin001100110010]=Y[0bin011010001001]);
-ASSERT(X[0bin001100110011]=X[0bin011010110111]);
-ASSERT(Y[0bin001100110011]=Y[0bin011010110111]);
-ASSERT(X[0bin001100110100]=X[0bin011011100101]);
-ASSERT(Y[0bin001100110100]=Y[0bin011011100101]);
-ASSERT(X[0bin001100110101]=X[0bin011100010011]);
-ASSERT(Y[0bin001100110101]=Y[0bin011100010011]);
-ASSERT(X[0bin001100110110]=X[0bin011101000001]);
-ASSERT(Y[0bin001100110110]=Y[0bin011101000001]);
-ASSERT(X[0bin001100110111]=X[0bin011101101111]);
-ASSERT(Y[0bin001100110111]=Y[0bin011101101111]);
-ASSERT(X[0bin001100111000]=X[0bin011110011101]);
-ASSERT(Y[0bin001100111000]=Y[0bin011110011101]);
-ASSERT(X[0bin001100111001]=X[0bin011111001011]);
-ASSERT(Y[0bin001100111001]=Y[0bin011111001011]);
-ASSERT(X[0bin001100111010]=X[0bin011111111001]);
-ASSERT(Y[0bin001100111010]=Y[0bin011111111001]);
-ASSERT(X[0bin001100111011]=X[0bin100000100111]);
-ASSERT(Y[0bin001100111011]=Y[0bin100000100111]);
-ASSERT(X[0bin001100111100]=X[0bin000000010010]);
-ASSERT(Y[0bin001100111100]=Y[0bin000000010010]);
-ASSERT(X[0bin001100111101]=X[0bin000001000000]);
-ASSERT(Y[0bin001100111101]=Y[0bin000001000000]);
-ASSERT(X[0bin001100111110]=X[0bin000001101110]);
-ASSERT(Y[0bin001100111110]=Y[0bin000001101110]);
-ASSERT(X[0bin001100111111]=X[0bin000010011100]);
-ASSERT(Y[0bin001100111111]=Y[0bin000010011100]);
-ASSERT(X[0bin001101000000]=X[0bin000011001010]);
-ASSERT(Y[0bin001101000000]=Y[0bin000011001010]);
-ASSERT(X[0bin001101000001]=X[0bin000011111000]);
-ASSERT(Y[0bin001101000001]=Y[0bin000011111000]);
-ASSERT(X[0bin001101000010]=X[0bin000100100110]);
-ASSERT(Y[0bin001101000010]=Y[0bin000100100110]);
-ASSERT(X[0bin001101000011]=X[0bin000101010100]);
-ASSERT(Y[0bin001101000011]=Y[0bin000101010100]);
-ASSERT(X[0bin001101000100]=X[0bin000110000010]);
-ASSERT(Y[0bin001101000100]=Y[0bin000110000010]);
-ASSERT(X[0bin001101000101]=X[0bin000110110000]);
-ASSERT(Y[0bin001101000101]=Y[0bin000110110000]);
-ASSERT(X[0bin001101000110]=X[0bin000111011110]);
-ASSERT(Y[0bin001101000110]=Y[0bin000111011110]);
-ASSERT(X[0bin001101000111]=X[0bin001000001100]);
-ASSERT(Y[0bin001101000111]=Y[0bin001000001100]);
-ASSERT(X[0bin001101001000]=X[0bin001000111010]);
-ASSERT(Y[0bin001101001000]=Y[0bin001000111010]);
-ASSERT(X[0bin001101001001]=X[0bin001001101000]);
-ASSERT(Y[0bin001101001001]=Y[0bin001001101000]);
-ASSERT(X[0bin001101001010]=X[0bin001010010110]);
-ASSERT(Y[0bin001101001010]=Y[0bin001010010110]);
-ASSERT(X[0bin001101001011]=X[0bin001011000100]);
-ASSERT(Y[0bin001101001011]=Y[0bin001011000100]);
-ASSERT(X[0bin001101001100]=X[0bin001011110010]);
-ASSERT(Y[0bin001101001100]=Y[0bin001011110010]);
-ASSERT(X[0bin001101001101]=X[0bin001100100000]);
-ASSERT(Y[0bin001101001101]=Y[0bin001100100000]);
-ASSERT(X[0bin001101001110]=X[0bin001101001110]);
-ASSERT(Y[0bin001101001110]=Y[0bin001101001110]);
-ASSERT(X[0bin001101001111]=X[0bin001101111100]);
-ASSERT(Y[0bin001101001111]=Y[0bin001101111100]);
-ASSERT(X[0bin001101010000]=X[0bin001110101010]);
-ASSERT(Y[0bin001101010000]=Y[0bin001110101010]);
-ASSERT(X[0bin001101010001]=X[0bin001111011000]);
-ASSERT(Y[0bin001101010001]=Y[0bin001111011000]);
-ASSERT(X[0bin001101010010]=X[0bin010000000110]);
-ASSERT(Y[0bin001101010010]=Y[0bin010000000110]);
-ASSERT(X[0bin001101010011]=X[0bin010000110100]);
-ASSERT(Y[0bin001101010011]=Y[0bin010000110100]);
-ASSERT(X[0bin001101010100]=X[0bin010001100010]);
-ASSERT(Y[0bin001101010100]=Y[0bin010001100010]);
-ASSERT(X[0bin001101010101]=X[0bin010010010000]);
-ASSERT(Y[0bin001101010101]=Y[0bin010010010000]);
-ASSERT(X[0bin001101010110]=X[0bin010010111110]);
-ASSERT(Y[0bin001101010110]=Y[0bin010010111110]);
-ASSERT(X[0bin001101010111]=X[0bin010011101100]);
-ASSERT(Y[0bin001101010111]=Y[0bin010011101100]);
-ASSERT(X[0bin001101011000]=X[0bin010100011010]);
-ASSERT(Y[0bin001101011000]=Y[0bin010100011010]);
-ASSERT(X[0bin001101011001]=X[0bin010101001000]);
-ASSERT(Y[0bin001101011001]=Y[0bin010101001000]);
-ASSERT(X[0bin001101011010]=X[0bin010101110110]);
-ASSERT(Y[0bin001101011010]=Y[0bin010101110110]);
-ASSERT(X[0bin001101011011]=X[0bin010110100100]);
-ASSERT(Y[0bin001101011011]=Y[0bin010110100100]);
-ASSERT(X[0bin001101011100]=X[0bin010111010010]);
-ASSERT(Y[0bin001101011100]=Y[0bin010111010010]);
-ASSERT(X[0bin001101011101]=X[0bin011000000000]);
-ASSERT(Y[0bin001101011101]=Y[0bin011000000000]);
-ASSERT(X[0bin001101011110]=X[0bin011000101110]);
-ASSERT(Y[0bin001101011110]=Y[0bin011000101110]);
-ASSERT(X[0bin001101011111]=X[0bin011001011100]);
-ASSERT(Y[0bin001101011111]=Y[0bin011001011100]);
-ASSERT(X[0bin001101100000]=X[0bin011010001010]);
-ASSERT(Y[0bin001101100000]=Y[0bin011010001010]);
-ASSERT(X[0bin001101100001]=X[0bin011010111000]);
-ASSERT(Y[0bin001101100001]=Y[0bin011010111000]);
-ASSERT(X[0bin001101100010]=X[0bin011011100110]);
-ASSERT(Y[0bin001101100010]=Y[0bin011011100110]);
-ASSERT(X[0bin001101100011]=X[0bin011100010100]);
-ASSERT(Y[0bin001101100011]=Y[0bin011100010100]);
-ASSERT(X[0bin001101100100]=X[0bin011101000010]);
-ASSERT(Y[0bin001101100100]=Y[0bin011101000010]);
-ASSERT(X[0bin001101100101]=X[0bin011101110000]);
-ASSERT(Y[0bin001101100101]=Y[0bin011101110000]);
-ASSERT(X[0bin001101100110]=X[0bin011110011110]);
-ASSERT(Y[0bin001101100110]=Y[0bin011110011110]);
-ASSERT(X[0bin001101100111]=X[0bin011111001100]);
-ASSERT(Y[0bin001101100111]=Y[0bin011111001100]);
-ASSERT(X[0bin001101101000]=X[0bin011111111010]);
-ASSERT(Y[0bin001101101000]=Y[0bin011111111010]);
-ASSERT(X[0bin001101101001]=X[0bin100000101000]);
-ASSERT(Y[0bin001101101001]=Y[0bin100000101000]);
-ASSERT(X[0bin001101101010]=X[0bin000000010011]);
-ASSERT(Y[0bin001101101010]=Y[0bin000000010011]);
-ASSERT(X[0bin001101101011]=X[0bin000001000001]);
-ASSERT(Y[0bin001101101011]=Y[0bin000001000001]);
-ASSERT(X[0bin001101101100]=X[0bin000001101111]);
-ASSERT(Y[0bin001101101100]=Y[0bin000001101111]);
-ASSERT(X[0bin001101101101]=X[0bin000010011101]);
-ASSERT(Y[0bin001101101101]=Y[0bin000010011101]);
-ASSERT(X[0bin001101101110]=X[0bin000011001011]);
-ASSERT(Y[0bin001101101110]=Y[0bin000011001011]);
-ASSERT(X[0bin001101101111]=X[0bin000011111001]);
-ASSERT(Y[0bin001101101111]=Y[0bin000011111001]);
-ASSERT(X[0bin001101110000]=X[0bin000100100111]);
-ASSERT(Y[0bin001101110000]=Y[0bin000100100111]);
-ASSERT(X[0bin001101110001]=X[0bin000101010101]);
-ASSERT(Y[0bin001101110001]=Y[0bin000101010101]);
-ASSERT(X[0bin001101110010]=X[0bin000110000011]);
-ASSERT(Y[0bin001101110010]=Y[0bin000110000011]);
-ASSERT(X[0bin001101110011]=X[0bin000110110001]);
-ASSERT(Y[0bin001101110011]=Y[0bin000110110001]);
-ASSERT(X[0bin001101110100]=X[0bin000111011111]);
-ASSERT(Y[0bin001101110100]=Y[0bin000111011111]);
-ASSERT(X[0bin001101110101]=X[0bin001000001101]);
-ASSERT(Y[0bin001101110101]=Y[0bin001000001101]);
-ASSERT(X[0bin001101110110]=X[0bin001000111011]);
-ASSERT(Y[0bin001101110110]=Y[0bin001000111011]);
-ASSERT(X[0bin001101110111]=X[0bin001001101001]);
-ASSERT(Y[0bin001101110111]=Y[0bin001001101001]);
-ASSERT(X[0bin001101111000]=X[0bin001010010111]);
-ASSERT(Y[0bin001101111000]=Y[0bin001010010111]);
-ASSERT(X[0bin001101111001]=X[0bin001011000101]);
-ASSERT(Y[0bin001101111001]=Y[0bin001011000101]);
-ASSERT(X[0bin001101111010]=X[0bin001011110011]);
-ASSERT(Y[0bin001101111010]=Y[0bin001011110011]);
-ASSERT(X[0bin001101111011]=X[0bin001100100001]);
-ASSERT(Y[0bin001101111011]=Y[0bin001100100001]);
-ASSERT(X[0bin001101111100]=X[0bin001101001111]);
-ASSERT(Y[0bin001101111100]=Y[0bin001101001111]);
-ASSERT(X[0bin001101111101]=X[0bin001101111101]);
-ASSERT(Y[0bin001101111101]=Y[0bin001101111101]);
-ASSERT(X[0bin001101111110]=X[0bin001110101011]);
-ASSERT(Y[0bin001101111110]=Y[0bin001110101011]);
-ASSERT(X[0bin001101111111]=X[0bin001111011001]);
-ASSERT(Y[0bin001101111111]=Y[0bin001111011001]);
-ASSERT(X[0bin001110000000]=X[0bin010000000111]);
-ASSERT(Y[0bin001110000000]=Y[0bin010000000111]);
-ASSERT(X[0bin001110000001]=X[0bin010000110101]);
-ASSERT(Y[0bin001110000001]=Y[0bin010000110101]);
-ASSERT(X[0bin001110000010]=X[0bin010001100011]);
-ASSERT(Y[0bin001110000010]=Y[0bin010001100011]);
-ASSERT(X[0bin001110000011]=X[0bin010010010001]);
-ASSERT(Y[0bin001110000011]=Y[0bin010010010001]);
-ASSERT(X[0bin001110000100]=X[0bin010010111111]);
-ASSERT(Y[0bin001110000100]=Y[0bin010010111111]);
-ASSERT(X[0bin001110000101]=X[0bin010011101101]);
-ASSERT(Y[0bin001110000101]=Y[0bin010011101101]);
-ASSERT(X[0bin001110000110]=X[0bin010100011011]);
-ASSERT(Y[0bin001110000110]=Y[0bin010100011011]);
-ASSERT(X[0bin001110000111]=X[0bin010101001001]);
-ASSERT(Y[0bin001110000111]=Y[0bin010101001001]);
-ASSERT(X[0bin001110001000]=X[0bin010101110111]);
-ASSERT(Y[0bin001110001000]=Y[0bin010101110111]);
-ASSERT(X[0bin001110001001]=X[0bin010110100101]);
-ASSERT(Y[0bin001110001001]=Y[0bin010110100101]);
-ASSERT(X[0bin001110001010]=X[0bin010111010011]);
-ASSERT(Y[0bin001110001010]=Y[0bin010111010011]);
-ASSERT(X[0bin001110001011]=X[0bin011000000001]);
-ASSERT(Y[0bin001110001011]=Y[0bin011000000001]);
-ASSERT(X[0bin001110001100]=X[0bin011000101111]);
-ASSERT(Y[0bin001110001100]=Y[0bin011000101111]);
-ASSERT(X[0bin001110001101]=X[0bin011001011101]);
-ASSERT(Y[0bin001110001101]=Y[0bin011001011101]);
-ASSERT(X[0bin001110001110]=X[0bin011010001011]);
-ASSERT(Y[0bin001110001110]=Y[0bin011010001011]);
-ASSERT(X[0bin001110001111]=X[0bin011010111001]);
-ASSERT(Y[0bin001110001111]=Y[0bin011010111001]);
-ASSERT(X[0bin001110010000]=X[0bin011011100111]);
-ASSERT(Y[0bin001110010000]=Y[0bin011011100111]);
-ASSERT(X[0bin001110010001]=X[0bin011100010101]);
-ASSERT(Y[0bin001110010001]=Y[0bin011100010101]);
-ASSERT(X[0bin001110010010]=X[0bin011101000011]);
-ASSERT(Y[0bin001110010010]=Y[0bin011101000011]);
-ASSERT(X[0bin001110010011]=X[0bin011101110001]);
-ASSERT(Y[0bin001110010011]=Y[0bin011101110001]);
-ASSERT(X[0bin001110010100]=X[0bin011110011111]);
-ASSERT(Y[0bin001110010100]=Y[0bin011110011111]);
-ASSERT(X[0bin001110010101]=X[0bin011111001101]);
-ASSERT(Y[0bin001110010101]=Y[0bin011111001101]);
-ASSERT(X[0bin001110010110]=X[0bin011111111011]);
-ASSERT(Y[0bin001110010110]=Y[0bin011111111011]);
-ASSERT(X[0bin001110010111]=X[0bin100000101001]);
-ASSERT(Y[0bin001110010111]=Y[0bin100000101001]);
-ASSERT(X[0bin001110011000]=X[0bin000000010100]);
-ASSERT(Y[0bin001110011000]=Y[0bin000000010100]);
-ASSERT(X[0bin001110011001]=X[0bin000001000010]);
-ASSERT(Y[0bin001110011001]=Y[0bin000001000010]);
-ASSERT(X[0bin001110011010]=X[0bin000001110000]);
-ASSERT(Y[0bin001110011010]=Y[0bin000001110000]);
-ASSERT(X[0bin001110011011]=X[0bin000010011110]);
-ASSERT(Y[0bin001110011011]=Y[0bin000010011110]);
-ASSERT(X[0bin001110011100]=X[0bin000011001100]);
-ASSERT(Y[0bin001110011100]=Y[0bin000011001100]);
-ASSERT(X[0bin001110011101]=X[0bin000011111010]);
-ASSERT(Y[0bin001110011101]=Y[0bin000011111010]);
-ASSERT(X[0bin001110011110]=X[0bin000100101000]);
-ASSERT(Y[0bin001110011110]=Y[0bin000100101000]);
-ASSERT(X[0bin001110011111]=X[0bin000101010110]);
-ASSERT(Y[0bin001110011111]=Y[0bin000101010110]);
-ASSERT(X[0bin001110100000]=X[0bin000110000100]);
-ASSERT(Y[0bin001110100000]=Y[0bin000110000100]);
-ASSERT(X[0bin001110100001]=X[0bin000110110010]);
-ASSERT(Y[0bin001110100001]=Y[0bin000110110010]);
-ASSERT(X[0bin001110100010]=X[0bin000111100000]);
-ASSERT(Y[0bin001110100010]=Y[0bin000111100000]);
-ASSERT(X[0bin001110100011]=X[0bin001000001110]);
-ASSERT(Y[0bin001110100011]=Y[0bin001000001110]);
-ASSERT(X[0bin001110100100]=X[0bin001000111100]);
-ASSERT(Y[0bin001110100100]=Y[0bin001000111100]);
-ASSERT(X[0bin001110100101]=X[0bin001001101010]);
-ASSERT(Y[0bin001110100101]=Y[0bin001001101010]);
-ASSERT(X[0bin001110100110]=X[0bin001010011000]);
-ASSERT(Y[0bin001110100110]=Y[0bin001010011000]);
-ASSERT(X[0bin001110100111]=X[0bin001011000110]);
-ASSERT(Y[0bin001110100111]=Y[0bin001011000110]);
-ASSERT(X[0bin001110101000]=X[0bin001011110100]);
-ASSERT(Y[0bin001110101000]=Y[0bin001011110100]);
-ASSERT(X[0bin001110101001]=X[0bin001100100010]);
-ASSERT(Y[0bin001110101001]=Y[0bin001100100010]);
-ASSERT(X[0bin001110101010]=X[0bin001101010000]);
-ASSERT(Y[0bin001110101010]=Y[0bin001101010000]);
-ASSERT(X[0bin001110101011]=X[0bin001101111110]);
-ASSERT(Y[0bin001110101011]=Y[0bin001101111110]);
-ASSERT(X[0bin001110101100]=X[0bin001110101100]);
-ASSERT(Y[0bin001110101100]=Y[0bin001110101100]);
-ASSERT(X[0bin001110101101]=X[0bin001111011010]);
-ASSERT(Y[0bin001110101101]=Y[0bin001111011010]);
-ASSERT(X[0bin001110101110]=X[0bin010000001000]);
-ASSERT(Y[0bin001110101110]=Y[0bin010000001000]);
-ASSERT(X[0bin001110101111]=X[0bin010000110110]);
-ASSERT(Y[0bin001110101111]=Y[0bin010000110110]);
-ASSERT(X[0bin001110110000]=X[0bin010001100100]);
-ASSERT(Y[0bin001110110000]=Y[0bin010001100100]);
-ASSERT(X[0bin001110110001]=X[0bin010010010010]);
-ASSERT(Y[0bin001110110001]=Y[0bin010010010010]);
-ASSERT(X[0bin001110110010]=X[0bin010011000000]);
-ASSERT(Y[0bin001110110010]=Y[0bin010011000000]);
-ASSERT(X[0bin001110110011]=X[0bin010011101110]);
-ASSERT(Y[0bin001110110011]=Y[0bin010011101110]);
-ASSERT(X[0bin001110110100]=X[0bin010100011100]);
-ASSERT(Y[0bin001110110100]=Y[0bin010100011100]);
-ASSERT(X[0bin001110110101]=X[0bin010101001010]);
-ASSERT(Y[0bin001110110101]=Y[0bin010101001010]);
-ASSERT(X[0bin001110110110]=X[0bin010101111000]);
-ASSERT(Y[0bin001110110110]=Y[0bin010101111000]);
-ASSERT(X[0bin001110110111]=X[0bin010110100110]);
-ASSERT(Y[0bin001110110111]=Y[0bin010110100110]);
-ASSERT(X[0bin001110111000]=X[0bin010111010100]);
-ASSERT(Y[0bin001110111000]=Y[0bin010111010100]);
-ASSERT(X[0bin001110111001]=X[0bin011000000010]);
-ASSERT(Y[0bin001110111001]=Y[0bin011000000010]);
-ASSERT(X[0bin001110111010]=X[0bin011000110000]);
-ASSERT(Y[0bin001110111010]=Y[0bin011000110000]);
-ASSERT(X[0bin001110111011]=X[0bin011001011110]);
-ASSERT(Y[0bin001110111011]=Y[0bin011001011110]);
-ASSERT(X[0bin001110111100]=X[0bin011010001100]);
-ASSERT(Y[0bin001110111100]=Y[0bin011010001100]);
-ASSERT(X[0bin001110111101]=X[0bin011010111010]);
-ASSERT(Y[0bin001110111101]=Y[0bin011010111010]);
-ASSERT(X[0bin001110111110]=X[0bin011011101000]);
-ASSERT(Y[0bin001110111110]=Y[0bin011011101000]);
-ASSERT(X[0bin001110111111]=X[0bin011100010110]);
-ASSERT(Y[0bin001110111111]=Y[0bin011100010110]);
-ASSERT(X[0bin001111000000]=X[0bin011101000100]);
-ASSERT(Y[0bin001111000000]=Y[0bin011101000100]);
-ASSERT(X[0bin001111000001]=X[0bin011101110010]);
-ASSERT(Y[0bin001111000001]=Y[0bin011101110010]);
-ASSERT(X[0bin001111000010]=X[0bin011110100000]);
-ASSERT(Y[0bin001111000010]=Y[0bin011110100000]);
-ASSERT(X[0bin001111000011]=X[0bin011111001110]);
-ASSERT(Y[0bin001111000011]=Y[0bin011111001110]);
-ASSERT(X[0bin001111000100]=X[0bin011111111100]);
-ASSERT(Y[0bin001111000100]=Y[0bin011111111100]);
-ASSERT(X[0bin001111000101]=X[0bin100000101010]);
-ASSERT(Y[0bin001111000101]=Y[0bin100000101010]);
-ASSERT(X[0bin001111000110]=X[0bin000000010101]);
-ASSERT(Y[0bin001111000110]=Y[0bin000000010101]);
-ASSERT(X[0bin001111000111]=X[0bin000001000011]);
-ASSERT(Y[0bin001111000111]=Y[0bin000001000011]);
-ASSERT(X[0bin001111001000]=X[0bin000001110001]);
-ASSERT(Y[0bin001111001000]=Y[0bin000001110001]);
-ASSERT(X[0bin001111001001]=X[0bin000010011111]);
-ASSERT(Y[0bin001111001001]=Y[0bin000010011111]);
-ASSERT(X[0bin001111001010]=X[0bin000011001101]);
-ASSERT(Y[0bin001111001010]=Y[0bin000011001101]);
-ASSERT(X[0bin001111001011]=X[0bin000011111011]);
-ASSERT(Y[0bin001111001011]=Y[0bin000011111011]);
-ASSERT(X[0bin001111001100]=X[0bin000100101001]);
-ASSERT(Y[0bin001111001100]=Y[0bin000100101001]);
-ASSERT(X[0bin001111001101]=X[0bin000101010111]);
-ASSERT(Y[0bin001111001101]=Y[0bin000101010111]);
-ASSERT(X[0bin001111001110]=X[0bin000110000101]);
-ASSERT(Y[0bin001111001110]=Y[0bin000110000101]);
-ASSERT(X[0bin001111001111]=X[0bin000110110011]);
-ASSERT(Y[0bin001111001111]=Y[0bin000110110011]);
-ASSERT(X[0bin001111010000]=X[0bin000111100001]);
-ASSERT(Y[0bin001111010000]=Y[0bin000111100001]);
-ASSERT(X[0bin001111010001]=X[0bin001000001111]);
-ASSERT(Y[0bin001111010001]=Y[0bin001000001111]);
-ASSERT(X[0bin001111010010]=X[0bin001000111101]);
-ASSERT(Y[0bin001111010010]=Y[0bin001000111101]);
-ASSERT(X[0bin001111010011]=X[0bin001001101011]);
-ASSERT(Y[0bin001111010011]=Y[0bin001001101011]);
-ASSERT(X[0bin001111010100]=X[0bin001010011001]);
-ASSERT(Y[0bin001111010100]=Y[0bin001010011001]);
-ASSERT(X[0bin001111010101]=X[0bin001011000111]);
-ASSERT(Y[0bin001111010101]=Y[0bin001011000111]);
-ASSERT(X[0bin001111010110]=X[0bin001011110101]);
-ASSERT(Y[0bin001111010110]=Y[0bin001011110101]);
-ASSERT(X[0bin001111010111]=X[0bin001100100011]);
-ASSERT(Y[0bin001111010111]=Y[0bin001100100011]);
-ASSERT(X[0bin001111011000]=X[0bin001101010001]);
-ASSERT(Y[0bin001111011000]=Y[0bin001101010001]);
-ASSERT(X[0bin001111011001]=X[0bin001101111111]);
-ASSERT(Y[0bin001111011001]=Y[0bin001101111111]);
-ASSERT(X[0bin001111011010]=X[0bin001110101101]);
-ASSERT(Y[0bin001111011010]=Y[0bin001110101101]);
-ASSERT(X[0bin001111011011]=X[0bin001111011011]);
-ASSERT(Y[0bin001111011011]=Y[0bin001111011011]);
-ASSERT(X[0bin001111011100]=X[0bin010000001001]);
-ASSERT(Y[0bin001111011100]=Y[0bin010000001001]);
-ASSERT(X[0bin001111011101]=X[0bin010000110111]);
-ASSERT(Y[0bin001111011101]=Y[0bin010000110111]);
-ASSERT(X[0bin001111011110]=X[0bin010001100101]);
-ASSERT(Y[0bin001111011110]=Y[0bin010001100101]);
-ASSERT(X[0bin001111011111]=X[0bin010010010011]);
-ASSERT(Y[0bin001111011111]=Y[0bin010010010011]);
-ASSERT(X[0bin001111100000]=X[0bin010011000001]);
-ASSERT(Y[0bin001111100000]=Y[0bin010011000001]);
-ASSERT(X[0bin001111100001]=X[0bin010011101111]);
-ASSERT(Y[0bin001111100001]=Y[0bin010011101111]);
-ASSERT(X[0bin001111100010]=X[0bin010100011101]);
-ASSERT(Y[0bin001111100010]=Y[0bin010100011101]);
-ASSERT(X[0bin001111100011]=X[0bin010101001011]);
-ASSERT(Y[0bin001111100011]=Y[0bin010101001011]);
-ASSERT(X[0bin001111100100]=X[0bin010101111001]);
-ASSERT(Y[0bin001111100100]=Y[0bin010101111001]);
-ASSERT(X[0bin001111100101]=X[0bin010110100111]);
-ASSERT(Y[0bin001111100101]=Y[0bin010110100111]);
-ASSERT(X[0bin001111100110]=X[0bin010111010101]);
-ASSERT(Y[0bin001111100110]=Y[0bin010111010101]);
-ASSERT(X[0bin001111100111]=X[0bin011000000011]);
-ASSERT(Y[0bin001111100111]=Y[0bin011000000011]);
-ASSERT(X[0bin001111101000]=X[0bin011000110001]);
-ASSERT(Y[0bin001111101000]=Y[0bin011000110001]);
-ASSERT(X[0bin001111101001]=X[0bin011001011111]);
-ASSERT(Y[0bin001111101001]=Y[0bin011001011111]);
-ASSERT(X[0bin001111101010]=X[0bin011010001101]);
-ASSERT(Y[0bin001111101010]=Y[0bin011010001101]);
-ASSERT(X[0bin001111101011]=X[0bin011010111011]);
-ASSERT(Y[0bin001111101011]=Y[0bin011010111011]);
-ASSERT(X[0bin001111101100]=X[0bin011011101001]);
-ASSERT(Y[0bin001111101100]=Y[0bin011011101001]);
-ASSERT(X[0bin001111101101]=X[0bin011100010111]);
-ASSERT(Y[0bin001111101101]=Y[0bin011100010111]);
-ASSERT(X[0bin001111101110]=X[0bin011101000101]);
-ASSERT(Y[0bin001111101110]=Y[0bin011101000101]);
-ASSERT(X[0bin001111101111]=X[0bin011101110011]);
-ASSERT(Y[0bin001111101111]=Y[0bin011101110011]);
-ASSERT(X[0bin001111110000]=X[0bin011110100001]);
-ASSERT(Y[0bin001111110000]=Y[0bin011110100001]);
-ASSERT(X[0bin001111110001]=X[0bin011111001111]);
-ASSERT(Y[0bin001111110001]=Y[0bin011111001111]);
-ASSERT(X[0bin001111110010]=X[0bin011111111101]);
-ASSERT(Y[0bin001111110010]=Y[0bin011111111101]);
-ASSERT(X[0bin001111110011]=X[0bin100000101011]);
-ASSERT(Y[0bin001111110011]=Y[0bin100000101011]);
-ASSERT(X[0bin001111110100]=X[0bin000000010110]);
-ASSERT(Y[0bin001111110100]=Y[0bin000000010110]);
-ASSERT(X[0bin001111110101]=X[0bin000001000100]);
-ASSERT(Y[0bin001111110101]=Y[0bin000001000100]);
-ASSERT(X[0bin001111110110]=X[0bin000001110010]);
-ASSERT(Y[0bin001111110110]=Y[0bin000001110010]);
-ASSERT(X[0bin001111110111]=X[0bin000010100000]);
-ASSERT(Y[0bin001111110111]=Y[0bin000010100000]);
-ASSERT(X[0bin001111111000]=X[0bin000011001110]);
-ASSERT(Y[0bin001111111000]=Y[0bin000011001110]);
-ASSERT(X[0bin001111111001]=X[0bin000011111100]);
-ASSERT(Y[0bin001111111001]=Y[0bin000011111100]);
-ASSERT(X[0bin001111111010]=X[0bin000100101010]);
-ASSERT(Y[0bin001111111010]=Y[0bin000100101010]);
-ASSERT(X[0bin001111111011]=X[0bin000101011000]);
-ASSERT(Y[0bin001111111011]=Y[0bin000101011000]);
-ASSERT(X[0bin001111111100]=X[0bin000110000110]);
-ASSERT(Y[0bin001111111100]=Y[0bin000110000110]);
-ASSERT(X[0bin001111111101]=X[0bin000110110100]);
-ASSERT(Y[0bin001111111101]=Y[0bin000110110100]);
-ASSERT(X[0bin001111111110]=X[0bin000111100010]);
-ASSERT(Y[0bin001111111110]=Y[0bin000111100010]);
-ASSERT(X[0bin001111111111]=X[0bin001000010000]);
-ASSERT(Y[0bin001111111111]=Y[0bin001000010000]);
-ASSERT(X[0bin010000000000]=X[0bin001000111110]);
-ASSERT(Y[0bin010000000000]=Y[0bin001000111110]);
-ASSERT(X[0bin010000000001]=X[0bin001001101100]);
-ASSERT(Y[0bin010000000001]=Y[0bin001001101100]);
-ASSERT(X[0bin010000000010]=X[0bin001010011010]);
-ASSERT(Y[0bin010000000010]=Y[0bin001010011010]);
-ASSERT(X[0bin010000000011]=X[0bin001011001000]);
-ASSERT(Y[0bin010000000011]=Y[0bin001011001000]);
-ASSERT(X[0bin010000000100]=X[0bin001011110110]);
-ASSERT(Y[0bin010000000100]=Y[0bin001011110110]);
-ASSERT(X[0bin010000000101]=X[0bin001100100100]);
-ASSERT(Y[0bin010000000101]=Y[0bin001100100100]);
-ASSERT(X[0bin010000000110]=X[0bin001101010010]);
-ASSERT(Y[0bin010000000110]=Y[0bin001101010010]);
-ASSERT(X[0bin010000000111]=X[0bin001110000000]);
-ASSERT(Y[0bin010000000111]=Y[0bin001110000000]);
-ASSERT(X[0bin010000001000]=X[0bin001110101110]);
-ASSERT(Y[0bin010000001000]=Y[0bin001110101110]);
-ASSERT(X[0bin010000001001]=X[0bin001111011100]);
-ASSERT(Y[0bin010000001001]=Y[0bin001111011100]);
-ASSERT(X[0bin010000001010]=X[0bin010000001010]);
-ASSERT(Y[0bin010000001010]=Y[0bin010000001010]);
-ASSERT(X[0bin010000001011]=X[0bin010000111000]);
-ASSERT(Y[0bin010000001011]=Y[0bin010000111000]);
-ASSERT(X[0bin010000001100]=X[0bin010001100110]);
-ASSERT(Y[0bin010000001100]=Y[0bin010001100110]);
-ASSERT(X[0bin010000001101]=X[0bin010010010100]);
-ASSERT(Y[0bin010000001101]=Y[0bin010010010100]);
-ASSERT(X[0bin010000001110]=X[0bin010011000010]);
-ASSERT(Y[0bin010000001110]=Y[0bin010011000010]);
-ASSERT(X[0bin010000001111]=X[0bin010011110000]);
-ASSERT(Y[0bin010000001111]=Y[0bin010011110000]);
-ASSERT(X[0bin010000010000]=X[0bin010100011110]);
-ASSERT(Y[0bin010000010000]=Y[0bin010100011110]);
-ASSERT(X[0bin010000010001]=X[0bin010101001100]);
-ASSERT(Y[0bin010000010001]=Y[0bin010101001100]);
-ASSERT(X[0bin010000010010]=X[0bin010101111010]);
-ASSERT(Y[0bin010000010010]=Y[0bin010101111010]);
-ASSERT(X[0bin010000010011]=X[0bin010110101000]);
-ASSERT(Y[0bin010000010011]=Y[0bin010110101000]);
-ASSERT(X[0bin010000010100]=X[0bin010111010110]);
-ASSERT(Y[0bin010000010100]=Y[0bin010111010110]);
-ASSERT(X[0bin010000010101]=X[0bin011000000100]);
-ASSERT(Y[0bin010000010101]=Y[0bin011000000100]);
-ASSERT(X[0bin010000010110]=X[0bin011000110010]);
-ASSERT(Y[0bin010000010110]=Y[0bin011000110010]);
-ASSERT(X[0bin010000010111]=X[0bin011001100000]);
-ASSERT(Y[0bin010000010111]=Y[0bin011001100000]);
-ASSERT(X[0bin010000011000]=X[0bin011010001110]);
-ASSERT(Y[0bin010000011000]=Y[0bin011010001110]);
-ASSERT(X[0bin010000011001]=X[0bin011010111100]);
-ASSERT(Y[0bin010000011001]=Y[0bin011010111100]);
-ASSERT(X[0bin010000011010]=X[0bin011011101010]);
-ASSERT(Y[0bin010000011010]=Y[0bin011011101010]);
-ASSERT(X[0bin010000011011]=X[0bin011100011000]);
-ASSERT(Y[0bin010000011011]=Y[0bin011100011000]);
-ASSERT(X[0bin010000011100]=X[0bin011101000110]);
-ASSERT(Y[0bin010000011100]=Y[0bin011101000110]);
-ASSERT(X[0bin010000011101]=X[0bin011101110100]);
-ASSERT(Y[0bin010000011101]=Y[0bin011101110100]);
-ASSERT(X[0bin010000011110]=X[0bin011110100010]);
-ASSERT(Y[0bin010000011110]=Y[0bin011110100010]);
-ASSERT(X[0bin010000011111]=X[0bin011111010000]);
-ASSERT(Y[0bin010000011111]=Y[0bin011111010000]);
-ASSERT(X[0bin010000100000]=X[0bin011111111110]);
-ASSERT(Y[0bin010000100000]=Y[0bin011111111110]);
-ASSERT(X[0bin010000100001]=X[0bin100000101100]);
-ASSERT(Y[0bin010000100001]=Y[0bin100000101100]);
-ASSERT(X[0bin010000100010]=X[0bin000000010111]);
-ASSERT(Y[0bin010000100010]=Y[0bin000000010111]);
-ASSERT(X[0bin010000100011]=X[0bin000001000101]);
-ASSERT(Y[0bin010000100011]=Y[0bin000001000101]);
-ASSERT(X[0bin010000100100]=X[0bin000001110011]);
-ASSERT(Y[0bin010000100100]=Y[0bin000001110011]);
-ASSERT(X[0bin010000100101]=X[0bin000010100001]);
-ASSERT(Y[0bin010000100101]=Y[0bin000010100001]);
-ASSERT(X[0bin010000100110]=X[0bin000011001111]);
-ASSERT(Y[0bin010000100110]=Y[0bin000011001111]);
-ASSERT(X[0bin010000100111]=X[0bin000011111101]);
-ASSERT(Y[0bin010000100111]=Y[0bin000011111101]);
-ASSERT(X[0bin010000101000]=X[0bin000100101011]);
-ASSERT(Y[0bin010000101000]=Y[0bin000100101011]);
-ASSERT(X[0bin010000101001]=X[0bin000101011001]);
-ASSERT(Y[0bin010000101001]=Y[0bin000101011001]);
-ASSERT(X[0bin010000101010]=X[0bin000110000111]);
-ASSERT(Y[0bin010000101010]=Y[0bin000110000111]);
-ASSERT(X[0bin010000101011]=X[0bin000110110101]);
-ASSERT(Y[0bin010000101011]=Y[0bin000110110101]);
-ASSERT(X[0bin010000101100]=X[0bin000111100011]);
-ASSERT(Y[0bin010000101100]=Y[0bin000111100011]);
-ASSERT(X[0bin010000101101]=X[0bin001000010001]);
-ASSERT(Y[0bin010000101101]=Y[0bin001000010001]);
-ASSERT(X[0bin010000101110]=X[0bin001000111111]);
-ASSERT(Y[0bin010000101110]=Y[0bin001000111111]);
-ASSERT(X[0bin010000101111]=X[0bin001001101101]);
-ASSERT(Y[0bin010000101111]=Y[0bin001001101101]);
-ASSERT(X[0bin010000110000]=X[0bin001010011011]);
-ASSERT(Y[0bin010000110000]=Y[0bin001010011011]);
-ASSERT(X[0bin010000110001]=X[0bin001011001001]);
-ASSERT(Y[0bin010000110001]=Y[0bin001011001001]);
-ASSERT(X[0bin010000110010]=X[0bin001011110111]);
-ASSERT(Y[0bin010000110010]=Y[0bin001011110111]);
-ASSERT(X[0bin010000110011]=X[0bin001100100101]);
-ASSERT(Y[0bin010000110011]=Y[0bin001100100101]);
-ASSERT(X[0bin010000110100]=X[0bin001101010011]);
-ASSERT(Y[0bin010000110100]=Y[0bin001101010011]);
-ASSERT(X[0bin010000110101]=X[0bin001110000001]);
-ASSERT(Y[0bin010000110101]=Y[0bin001110000001]);
-ASSERT(X[0bin010000110110]=X[0bin001110101111]);
-ASSERT(Y[0bin010000110110]=Y[0bin001110101111]);
-ASSERT(X[0bin010000110111]=X[0bin001111011101]);
-ASSERT(Y[0bin010000110111]=Y[0bin001111011101]);
-ASSERT(X[0bin010000111000]=X[0bin010000001011]);
-ASSERT(Y[0bin010000111000]=Y[0bin010000001011]);
-ASSERT(X[0bin010000111001]=X[0bin010000111001]);
-ASSERT(Y[0bin010000111001]=Y[0bin010000111001]);
-ASSERT(X[0bin010000111010]=X[0bin010001100111]);
-ASSERT(Y[0bin010000111010]=Y[0bin010001100111]);
-ASSERT(X[0bin010000111011]=X[0bin010010010101]);
-ASSERT(Y[0bin010000111011]=Y[0bin010010010101]);
-ASSERT(X[0bin010000111100]=X[0bin010011000011]);
-ASSERT(Y[0bin010000111100]=Y[0bin010011000011]);
-ASSERT(X[0bin010000111101]=X[0bin010011110001]);
-ASSERT(Y[0bin010000111101]=Y[0bin010011110001]);
-ASSERT(X[0bin010000111110]=X[0bin010100011111]);
-ASSERT(Y[0bin010000111110]=Y[0bin010100011111]);
-ASSERT(X[0bin010000111111]=X[0bin010101001101]);
-ASSERT(Y[0bin010000111111]=Y[0bin010101001101]);
-ASSERT(X[0bin010001000000]=X[0bin010101111011]);
-ASSERT(Y[0bin010001000000]=Y[0bin010101111011]);
-ASSERT(X[0bin010001000001]=X[0bin010110101001]);
-ASSERT(Y[0bin010001000001]=Y[0bin010110101001]);
-ASSERT(X[0bin010001000010]=X[0bin010111010111]);
-ASSERT(Y[0bin010001000010]=Y[0bin010111010111]);
-ASSERT(X[0bin010001000011]=X[0bin011000000101]);
-ASSERT(Y[0bin010001000011]=Y[0bin011000000101]);
-ASSERT(X[0bin010001000100]=X[0bin011000110011]);
-ASSERT(Y[0bin010001000100]=Y[0bin011000110011]);
-ASSERT(X[0bin010001000101]=X[0bin011001100001]);
-ASSERT(Y[0bin010001000101]=Y[0bin011001100001]);
-ASSERT(X[0bin010001000110]=X[0bin011010001111]);
-ASSERT(Y[0bin010001000110]=Y[0bin011010001111]);
-ASSERT(X[0bin010001000111]=X[0bin011010111101]);
-ASSERT(Y[0bin010001000111]=Y[0bin011010111101]);
-ASSERT(X[0bin010001001000]=X[0bin011011101011]);
-ASSERT(Y[0bin010001001000]=Y[0bin011011101011]);
-ASSERT(X[0bin010001001001]=X[0bin011100011001]);
-ASSERT(Y[0bin010001001001]=Y[0bin011100011001]);
-ASSERT(X[0bin010001001010]=X[0bin011101000111]);
-ASSERT(Y[0bin010001001010]=Y[0bin011101000111]);
-ASSERT(X[0bin010001001011]=X[0bin011101110101]);
-ASSERT(Y[0bin010001001011]=Y[0bin011101110101]);
-ASSERT(X[0bin010001001100]=X[0bin011110100011]);
-ASSERT(Y[0bin010001001100]=Y[0bin011110100011]);
-ASSERT(X[0bin010001001101]=X[0bin011111010001]);
-ASSERT(Y[0bin010001001101]=Y[0bin011111010001]);
-ASSERT(X[0bin010001001110]=X[0bin011111111111]);
-ASSERT(Y[0bin010001001110]=Y[0bin011111111111]);
-ASSERT(X[0bin010001001111]=X[0bin100000101101]);
-ASSERT(Y[0bin010001001111]=Y[0bin100000101101]);
-ASSERT(X[0bin010001010000]=X[0bin000000011000]);
-ASSERT(Y[0bin010001010000]=Y[0bin000000011000]);
-ASSERT(X[0bin010001010001]=X[0bin000001000110]);
-ASSERT(Y[0bin010001010001]=Y[0bin000001000110]);
-ASSERT(X[0bin010001010010]=X[0bin000001110100]);
-ASSERT(Y[0bin010001010010]=Y[0bin000001110100]);
-ASSERT(X[0bin010001010011]=X[0bin000010100010]);
-ASSERT(Y[0bin010001010011]=Y[0bin000010100010]);
-ASSERT(X[0bin010001010100]=X[0bin000011010000]);
-ASSERT(Y[0bin010001010100]=Y[0bin000011010000]);
-ASSERT(X[0bin010001010101]=X[0bin000011111110]);
-ASSERT(Y[0bin010001010101]=Y[0bin000011111110]);
-ASSERT(X[0bin010001010110]=X[0bin000100101100]);
-ASSERT(Y[0bin010001010110]=Y[0bin000100101100]);
-ASSERT(X[0bin010001010111]=X[0bin000101011010]);
-ASSERT(Y[0bin010001010111]=Y[0bin000101011010]);
-ASSERT(X[0bin010001011000]=X[0bin000110001000]);
-ASSERT(Y[0bin010001011000]=Y[0bin000110001000]);
-ASSERT(X[0bin010001011001]=X[0bin000110110110]);
-ASSERT(Y[0bin010001011001]=Y[0bin000110110110]);
-ASSERT(X[0bin010001011010]=X[0bin000111100100]);
-ASSERT(Y[0bin010001011010]=Y[0bin000111100100]);
-ASSERT(X[0bin010001011011]=X[0bin001000010010]);
-ASSERT(Y[0bin010001011011]=Y[0bin001000010010]);
-ASSERT(X[0bin010001011100]=X[0bin001001000000]);
-ASSERT(Y[0bin010001011100]=Y[0bin001001000000]);
-ASSERT(X[0bin010001011101]=X[0bin001001101110]);
-ASSERT(Y[0bin010001011101]=Y[0bin001001101110]);
-ASSERT(X[0bin010001011110]=X[0bin001010011100]);
-ASSERT(Y[0bin010001011110]=Y[0bin001010011100]);
-ASSERT(X[0bin010001011111]=X[0bin001011001010]);
-ASSERT(Y[0bin010001011111]=Y[0bin001011001010]);
-ASSERT(X[0bin010001100000]=X[0bin001011111000]);
-ASSERT(Y[0bin010001100000]=Y[0bin001011111000]);
-ASSERT(X[0bin010001100001]=X[0bin001100100110]);
-ASSERT(Y[0bin010001100001]=Y[0bin001100100110]);
-ASSERT(X[0bin010001100010]=X[0bin001101010100]);
-ASSERT(Y[0bin010001100010]=Y[0bin001101010100]);
-ASSERT(X[0bin010001100011]=X[0bin001110000010]);
-ASSERT(Y[0bin010001100011]=Y[0bin001110000010]);
-ASSERT(X[0bin010001100100]=X[0bin001110110000]);
-ASSERT(Y[0bin010001100100]=Y[0bin001110110000]);
-ASSERT(X[0bin010001100101]=X[0bin001111011110]);
-ASSERT(Y[0bin010001100101]=Y[0bin001111011110]);
-ASSERT(X[0bin010001100110]=X[0bin010000001100]);
-ASSERT(Y[0bin010001100110]=Y[0bin010000001100]);
-ASSERT(X[0bin010001100111]=X[0bin010000111010]);
-ASSERT(Y[0bin010001100111]=Y[0bin010000111010]);
-ASSERT(X[0bin010001101000]=X[0bin010001101000]);
-ASSERT(Y[0bin010001101000]=Y[0bin010001101000]);
-ASSERT(X[0bin010001101001]=X[0bin010010010110]);
-ASSERT(Y[0bin010001101001]=Y[0bin010010010110]);
-ASSERT(X[0bin010001101010]=X[0bin010011000100]);
-ASSERT(Y[0bin010001101010]=Y[0bin010011000100]);
-ASSERT(X[0bin010001101011]=X[0bin010011110010]);
-ASSERT(Y[0bin010001101011]=Y[0bin010011110010]);
-ASSERT(X[0bin010001101100]=X[0bin010100100000]);
-ASSERT(Y[0bin010001101100]=Y[0bin010100100000]);
-ASSERT(X[0bin010001101101]=X[0bin010101001110]);
-ASSERT(Y[0bin010001101101]=Y[0bin010101001110]);
-ASSERT(X[0bin010001101110]=X[0bin010101111100]);
-ASSERT(Y[0bin010001101110]=Y[0bin010101111100]);
-ASSERT(X[0bin010001101111]=X[0bin010110101010]);
-ASSERT(Y[0bin010001101111]=Y[0bin010110101010]);
-ASSERT(X[0bin010001110000]=X[0bin010111011000]);
-ASSERT(Y[0bin010001110000]=Y[0bin010111011000]);
-ASSERT(X[0bin010001110001]=X[0bin011000000110]);
-ASSERT(Y[0bin010001110001]=Y[0bin011000000110]);
-ASSERT(X[0bin010001110010]=X[0bin011000110100]);
-ASSERT(Y[0bin010001110010]=Y[0bin011000110100]);
-ASSERT(X[0bin010001110011]=X[0bin011001100010]);
-ASSERT(Y[0bin010001110011]=Y[0bin011001100010]);
-ASSERT(X[0bin010001110100]=X[0bin011010010000]);
-ASSERT(Y[0bin010001110100]=Y[0bin011010010000]);
-ASSERT(X[0bin010001110101]=X[0bin011010111110]);
-ASSERT(Y[0bin010001110101]=Y[0bin011010111110]);
-ASSERT(X[0bin010001110110]=X[0bin011011101100]);
-ASSERT(Y[0bin010001110110]=Y[0bin011011101100]);
-ASSERT(X[0bin010001110111]=X[0bin011100011010]);
-ASSERT(Y[0bin010001110111]=Y[0bin011100011010]);
-ASSERT(X[0bin010001111000]=X[0bin011101001000]);
-ASSERT(Y[0bin010001111000]=Y[0bin011101001000]);
-ASSERT(X[0bin010001111001]=X[0bin011101110110]);
-ASSERT(Y[0bin010001111001]=Y[0bin011101110110]);
-ASSERT(X[0bin010001111010]=X[0bin011110100100]);
-ASSERT(Y[0bin010001111010]=Y[0bin011110100100]);
-ASSERT(X[0bin010001111011]=X[0bin011111010010]);
-ASSERT(Y[0bin010001111011]=Y[0bin011111010010]);
-ASSERT(X[0bin010001111100]=X[0bin100000000000]);
-ASSERT(Y[0bin010001111100]=Y[0bin100000000000]);
-ASSERT(X[0bin010001111101]=X[0bin100000101110]);
-ASSERT(Y[0bin010001111101]=Y[0bin100000101110]);
-ASSERT(X[0bin010001111110]=X[0bin000000011001]);
-ASSERT(Y[0bin010001111110]=Y[0bin000000011001]);
-ASSERT(X[0bin010001111111]=X[0bin000001000111]);
-ASSERT(Y[0bin010001111111]=Y[0bin000001000111]);
-ASSERT(X[0bin010010000000]=X[0bin000001110101]);
-ASSERT(Y[0bin010010000000]=Y[0bin000001110101]);
-ASSERT(X[0bin010010000001]=X[0bin000010100011]);
-ASSERT(Y[0bin010010000001]=Y[0bin000010100011]);
-ASSERT(X[0bin010010000010]=X[0bin000011010001]);
-ASSERT(Y[0bin010010000010]=Y[0bin000011010001]);
-ASSERT(X[0bin010010000011]=X[0bin000011111111]);
-ASSERT(Y[0bin010010000011]=Y[0bin000011111111]);
-ASSERT(X[0bin010010000100]=X[0bin000100101101]);
-ASSERT(Y[0bin010010000100]=Y[0bin000100101101]);
-ASSERT(X[0bin010010000101]=X[0bin000101011011]);
-ASSERT(Y[0bin010010000101]=Y[0bin000101011011]);
-ASSERT(X[0bin010010000110]=X[0bin000110001001]);
-ASSERT(Y[0bin010010000110]=Y[0bin000110001001]);
-ASSERT(X[0bin010010000111]=X[0bin000110110111]);
-ASSERT(Y[0bin010010000111]=Y[0bin000110110111]);
-ASSERT(X[0bin010010001000]=X[0bin000111100101]);
-ASSERT(Y[0bin010010001000]=Y[0bin000111100101]);
-ASSERT(X[0bin010010001001]=X[0bin001000010011]);
-ASSERT(Y[0bin010010001001]=Y[0bin001000010011]);
-ASSERT(X[0bin010010001010]=X[0bin001001000001]);
-ASSERT(Y[0bin010010001010]=Y[0bin001001000001]);
-ASSERT(X[0bin010010001011]=X[0bin001001101111]);
-ASSERT(Y[0bin010010001011]=Y[0bin001001101111]);
-ASSERT(X[0bin010010001100]=X[0bin001010011101]);
-ASSERT(Y[0bin010010001100]=Y[0bin001010011101]);
-ASSERT(X[0bin010010001101]=X[0bin001011001011]);
-ASSERT(Y[0bin010010001101]=Y[0bin001011001011]);
-ASSERT(X[0bin010010001110]=X[0bin001011111001]);
-ASSERT(Y[0bin010010001110]=Y[0bin001011111001]);
-ASSERT(X[0bin010010001111]=X[0bin001100100111]);
-ASSERT(Y[0bin010010001111]=Y[0bin001100100111]);
-ASSERT(X[0bin010010010000]=X[0bin001101010101]);
-ASSERT(Y[0bin010010010000]=Y[0bin001101010101]);
-ASSERT(X[0bin010010010001]=X[0bin001110000011]);
-ASSERT(Y[0bin010010010001]=Y[0bin001110000011]);
-ASSERT(X[0bin010010010010]=X[0bin001110110001]);
-ASSERT(Y[0bin010010010010]=Y[0bin001110110001]);
-ASSERT(X[0bin010010010011]=X[0bin001111011111]);
-ASSERT(Y[0bin010010010011]=Y[0bin001111011111]);
-ASSERT(X[0bin010010010100]=X[0bin010000001101]);
-ASSERT(Y[0bin010010010100]=Y[0bin010000001101]);
-ASSERT(X[0bin010010010101]=X[0bin010000111011]);
-ASSERT(Y[0bin010010010101]=Y[0bin010000111011]);
-ASSERT(X[0bin010010010110]=X[0bin010001101001]);
-ASSERT(Y[0bin010010010110]=Y[0bin010001101001]);
-ASSERT(X[0bin010010010111]=X[0bin010010010111]);
-ASSERT(Y[0bin010010010111]=Y[0bin010010010111]);
-ASSERT(X[0bin010010011000]=X[0bin010011000101]);
-ASSERT(Y[0bin010010011000]=Y[0bin010011000101]);
-ASSERT(X[0bin010010011001]=X[0bin010011110011]);
-ASSERT(Y[0bin010010011001]=Y[0bin010011110011]);
-ASSERT(X[0bin010010011010]=X[0bin010100100001]);
-ASSERT(Y[0bin010010011010]=Y[0bin010100100001]);
-ASSERT(X[0bin010010011011]=X[0bin010101001111]);
-ASSERT(Y[0bin010010011011]=Y[0bin010101001111]);
-ASSERT(X[0bin010010011100]=X[0bin010101111101]);
-ASSERT(Y[0bin010010011100]=Y[0bin010101111101]);
-ASSERT(X[0bin010010011101]=X[0bin010110101011]);
-ASSERT(Y[0bin010010011101]=Y[0bin010110101011]);
-ASSERT(X[0bin010010011110]=X[0bin010111011001]);
-ASSERT(Y[0bin010010011110]=Y[0bin010111011001]);
-ASSERT(X[0bin010010011111]=X[0bin011000000111]);
-ASSERT(Y[0bin010010011111]=Y[0bin011000000111]);
-ASSERT(X[0bin010010100000]=X[0bin011000110101]);
-ASSERT(Y[0bin010010100000]=Y[0bin011000110101]);
-ASSERT(X[0bin010010100001]=X[0bin011001100011]);
-ASSERT(Y[0bin010010100001]=Y[0bin011001100011]);
-ASSERT(X[0bin010010100010]=X[0bin011010010001]);
-ASSERT(Y[0bin010010100010]=Y[0bin011010010001]);
-ASSERT(X[0bin010010100011]=X[0bin011010111111]);
-ASSERT(Y[0bin010010100011]=Y[0bin011010111111]);
-ASSERT(X[0bin010010100100]=X[0bin011011101101]);
-ASSERT(Y[0bin010010100100]=Y[0bin011011101101]);
-ASSERT(X[0bin010010100101]=X[0bin011100011011]);
-ASSERT(Y[0bin010010100101]=Y[0bin011100011011]);
-ASSERT(X[0bin010010100110]=X[0bin011101001001]);
-ASSERT(Y[0bin010010100110]=Y[0bin011101001001]);
-ASSERT(X[0bin010010100111]=X[0bin011101110111]);
-ASSERT(Y[0bin010010100111]=Y[0bin011101110111]);
-ASSERT(X[0bin010010101000]=X[0bin011110100101]);
-ASSERT(Y[0bin010010101000]=Y[0bin011110100101]);
-ASSERT(X[0bin010010101001]=X[0bin011111010011]);
-ASSERT(Y[0bin010010101001]=Y[0bin011111010011]);
-ASSERT(X[0bin010010101010]=X[0bin100000000001]);
-ASSERT(Y[0bin010010101010]=Y[0bin100000000001]);
-ASSERT(X[0bin010010101011]=X[0bin100000101111]);
-ASSERT(Y[0bin010010101011]=Y[0bin100000101111]);
-ASSERT(X[0bin010010101100]=X[0bin000000011010]);
-ASSERT(Y[0bin010010101100]=Y[0bin000000011010]);
-ASSERT(X[0bin010010101101]=X[0bin000001001000]);
-ASSERT(Y[0bin010010101101]=Y[0bin000001001000]);
-ASSERT(X[0bin010010101110]=X[0bin000001110110]);
-ASSERT(Y[0bin010010101110]=Y[0bin000001110110]);
-ASSERT(X[0bin010010101111]=X[0bin000010100100]);
-ASSERT(Y[0bin010010101111]=Y[0bin000010100100]);
-ASSERT(X[0bin010010110000]=X[0bin000011010010]);
-ASSERT(Y[0bin010010110000]=Y[0bin000011010010]);
-ASSERT(X[0bin010010110001]=X[0bin000100000000]);
-ASSERT(Y[0bin010010110001]=Y[0bin000100000000]);
-ASSERT(X[0bin010010110010]=X[0bin000100101110]);
-ASSERT(Y[0bin010010110010]=Y[0bin000100101110]);
-ASSERT(X[0bin010010110011]=X[0bin000101011100]);
-ASSERT(Y[0bin010010110011]=Y[0bin000101011100]);
-ASSERT(X[0bin010010110100]=X[0bin000110001010]);
-ASSERT(Y[0bin010010110100]=Y[0bin000110001010]);
-ASSERT(X[0bin010010110101]=X[0bin000110111000]);
-ASSERT(Y[0bin010010110101]=Y[0bin000110111000]);
-ASSERT(X[0bin010010110110]=X[0bin000111100110]);
-ASSERT(Y[0bin010010110110]=Y[0bin000111100110]);
-ASSERT(X[0bin010010110111]=X[0bin001000010100]);
-ASSERT(Y[0bin010010110111]=Y[0bin001000010100]);
-ASSERT(X[0bin010010111000]=X[0bin001001000010]);
-ASSERT(Y[0bin010010111000]=Y[0bin001001000010]);
-ASSERT(X[0bin010010111001]=X[0bin001001110000]);
-ASSERT(Y[0bin010010111001]=Y[0bin001001110000]);
-ASSERT(X[0bin010010111010]=X[0bin001010011110]);
-ASSERT(Y[0bin010010111010]=Y[0bin001010011110]);
-ASSERT(X[0bin010010111011]=X[0bin001011001100]);
-ASSERT(Y[0bin010010111011]=Y[0bin001011001100]);
-ASSERT(X[0bin010010111100]=X[0bin001011111010]);
-ASSERT(Y[0bin010010111100]=Y[0bin001011111010]);
-ASSERT(X[0bin010010111101]=X[0bin001100101000]);
-ASSERT(Y[0bin010010111101]=Y[0bin001100101000]);
-ASSERT(X[0bin010010111110]=X[0bin001101010110]);
-ASSERT(Y[0bin010010111110]=Y[0bin001101010110]);
-ASSERT(X[0bin010010111111]=X[0bin001110000100]);
-ASSERT(Y[0bin010010111111]=Y[0bin001110000100]);
-ASSERT(X[0bin010011000000]=X[0bin001110110010]);
-ASSERT(Y[0bin010011000000]=Y[0bin001110110010]);
-ASSERT(X[0bin010011000001]=X[0bin001111100000]);
-ASSERT(Y[0bin010011000001]=Y[0bin001111100000]);
-ASSERT(X[0bin010011000010]=X[0bin010000001110]);
-ASSERT(Y[0bin010011000010]=Y[0bin010000001110]);
-ASSERT(X[0bin010011000011]=X[0bin010000111100]);
-ASSERT(Y[0bin010011000011]=Y[0bin010000111100]);
-ASSERT(X[0bin010011000100]=X[0bin010001101010]);
-ASSERT(Y[0bin010011000100]=Y[0bin010001101010]);
-ASSERT(X[0bin010011000101]=X[0bin010010011000]);
-ASSERT(Y[0bin010011000101]=Y[0bin010010011000]);
-ASSERT(X[0bin010011000110]=X[0bin010011000110]);
-ASSERT(Y[0bin010011000110]=Y[0bin010011000110]);
-ASSERT(X[0bin010011000111]=X[0bin010011110100]);
-ASSERT(Y[0bin010011000111]=Y[0bin010011110100]);
-ASSERT(X[0bin010011001000]=X[0bin010100100010]);
-ASSERT(Y[0bin010011001000]=Y[0bin010100100010]);
-ASSERT(X[0bin010011001001]=X[0bin010101010000]);
-ASSERT(Y[0bin010011001001]=Y[0bin010101010000]);
-ASSERT(X[0bin010011001010]=X[0bin010101111110]);
-ASSERT(Y[0bin010011001010]=Y[0bin010101111110]);
-ASSERT(X[0bin010011001011]=X[0bin010110101100]);
-ASSERT(Y[0bin010011001011]=Y[0bin010110101100]);
-ASSERT(X[0bin010011001100]=X[0bin010111011010]);
-ASSERT(Y[0bin010011001100]=Y[0bin010111011010]);
-ASSERT(X[0bin010011001101]=X[0bin011000001000]);
-ASSERT(Y[0bin010011001101]=Y[0bin011000001000]);
-ASSERT(X[0bin010011001110]=X[0bin011000110110]);
-ASSERT(Y[0bin010011001110]=Y[0bin011000110110]);
-ASSERT(X[0bin010011001111]=X[0bin011001100100]);
-ASSERT(Y[0bin010011001111]=Y[0bin011001100100]);
-ASSERT(X[0bin010011010000]=X[0bin011010010010]);
-ASSERT(Y[0bin010011010000]=Y[0bin011010010010]);
-ASSERT(X[0bin010011010001]=X[0bin011011000000]);
-ASSERT(Y[0bin010011010001]=Y[0bin011011000000]);
-ASSERT(X[0bin010011010010]=X[0bin011011101110]);
-ASSERT(Y[0bin010011010010]=Y[0bin011011101110]);
-ASSERT(X[0bin010011010011]=X[0bin011100011100]);
-ASSERT(Y[0bin010011010011]=Y[0bin011100011100]);
-ASSERT(X[0bin010011010100]=X[0bin011101001010]);
-ASSERT(Y[0bin010011010100]=Y[0bin011101001010]);
-ASSERT(X[0bin010011010101]=X[0bin011101111000]);
-ASSERT(Y[0bin010011010101]=Y[0bin011101111000]);
-ASSERT(X[0bin010011010110]=X[0bin011110100110]);
-ASSERT(Y[0bin010011010110]=Y[0bin011110100110]);
-ASSERT(X[0bin010011010111]=X[0bin011111010100]);
-ASSERT(Y[0bin010011010111]=Y[0bin011111010100]);
-ASSERT(X[0bin010011011000]=X[0bin100000000010]);
-ASSERT(Y[0bin010011011000]=Y[0bin100000000010]);
-ASSERT(X[0bin010011011001]=X[0bin100000110000]);
-ASSERT(Y[0bin010011011001]=Y[0bin100000110000]);
-ASSERT(X[0bin010011011010]=X[0bin000000011011]);
-ASSERT(Y[0bin010011011010]=Y[0bin000000011011]);
-ASSERT(X[0bin010011011011]=X[0bin000001001001]);
-ASSERT(Y[0bin010011011011]=Y[0bin000001001001]);
-ASSERT(X[0bin010011011100]=X[0bin000001110111]);
-ASSERT(Y[0bin010011011100]=Y[0bin000001110111]);
-ASSERT(X[0bin010011011101]=X[0bin000010100101]);
-ASSERT(Y[0bin010011011101]=Y[0bin000010100101]);
-ASSERT(X[0bin010011011110]=X[0bin000011010011]);
-ASSERT(Y[0bin010011011110]=Y[0bin000011010011]);
-ASSERT(X[0bin010011011111]=X[0bin000100000001]);
-ASSERT(Y[0bin010011011111]=Y[0bin000100000001]);
-ASSERT(X[0bin010011100000]=X[0bin000100101111]);
-ASSERT(Y[0bin010011100000]=Y[0bin000100101111]);
-ASSERT(X[0bin010011100001]=X[0bin000101011101]);
-ASSERT(Y[0bin010011100001]=Y[0bin000101011101]);
-ASSERT(X[0bin010011100010]=X[0bin000110001011]);
-ASSERT(Y[0bin010011100010]=Y[0bin000110001011]);
-ASSERT(X[0bin010011100011]=X[0bin000110111001]);
-ASSERT(Y[0bin010011100011]=Y[0bin000110111001]);
-ASSERT(X[0bin010011100100]=X[0bin000111100111]);
-ASSERT(Y[0bin010011100100]=Y[0bin000111100111]);
-ASSERT(X[0bin010011100101]=X[0bin001000010101]);
-ASSERT(Y[0bin010011100101]=Y[0bin001000010101]);
-ASSERT(X[0bin010011100110]=X[0bin001001000011]);
-ASSERT(Y[0bin010011100110]=Y[0bin001001000011]);
-ASSERT(X[0bin010011100111]=X[0bin001001110001]);
-ASSERT(Y[0bin010011100111]=Y[0bin001001110001]);
-ASSERT(X[0bin010011101000]=X[0bin001010011111]);
-ASSERT(Y[0bin010011101000]=Y[0bin001010011111]);
-ASSERT(X[0bin010011101001]=X[0bin001011001101]);
-ASSERT(Y[0bin010011101001]=Y[0bin001011001101]);
-ASSERT(X[0bin010011101010]=X[0bin001011111011]);
-ASSERT(Y[0bin010011101010]=Y[0bin001011111011]);
-ASSERT(X[0bin010011101011]=X[0bin001100101001]);
-ASSERT(Y[0bin010011101011]=Y[0bin001100101001]);
-ASSERT(X[0bin010011101100]=X[0bin001101010111]);
-ASSERT(Y[0bin010011101100]=Y[0bin001101010111]);
-ASSERT(X[0bin010011101101]=X[0bin001110000101]);
-ASSERT(Y[0bin010011101101]=Y[0bin001110000101]);
-ASSERT(X[0bin010011101110]=X[0bin001110110011]);
-ASSERT(Y[0bin010011101110]=Y[0bin001110110011]);
-ASSERT(X[0bin010011101111]=X[0bin001111100001]);
-ASSERT(Y[0bin010011101111]=Y[0bin001111100001]);
-ASSERT(X[0bin010011110000]=X[0bin010000001111]);
-ASSERT(Y[0bin010011110000]=Y[0bin010000001111]);
-ASSERT(X[0bin010011110001]=X[0bin010000111101]);
-ASSERT(Y[0bin010011110001]=Y[0bin010000111101]);
-ASSERT(X[0bin010011110010]=X[0bin010001101011]);
-ASSERT(Y[0bin010011110010]=Y[0bin010001101011]);
-ASSERT(X[0bin010011110011]=X[0bin010010011001]);
-ASSERT(Y[0bin010011110011]=Y[0bin010010011001]);
-ASSERT(X[0bin010011110100]=X[0bin010011000111]);
-ASSERT(Y[0bin010011110100]=Y[0bin010011000111]);
-ASSERT(X[0bin010011110101]=X[0bin010011110101]);
-ASSERT(Y[0bin010011110101]=Y[0bin010011110101]);
-ASSERT(X[0bin010011110110]=X[0bin010100100011]);
-ASSERT(Y[0bin010011110110]=Y[0bin010100100011]);
-ASSERT(X[0bin010011110111]=X[0bin010101010001]);
-ASSERT(Y[0bin010011110111]=Y[0bin010101010001]);
-ASSERT(X[0bin010011111000]=X[0bin010101111111]);
-ASSERT(Y[0bin010011111000]=Y[0bin010101111111]);
-ASSERT(X[0bin010011111001]=X[0bin010110101101]);
-ASSERT(Y[0bin010011111001]=Y[0bin010110101101]);
-ASSERT(X[0bin010011111010]=X[0bin010111011011]);
-ASSERT(Y[0bin010011111010]=Y[0bin010111011011]);
-ASSERT(X[0bin010011111011]=X[0bin011000001001]);
-ASSERT(Y[0bin010011111011]=Y[0bin011000001001]);
-ASSERT(X[0bin010011111100]=X[0bin011000110111]);
-ASSERT(Y[0bin010011111100]=Y[0bin011000110111]);
-ASSERT(X[0bin010011111101]=X[0bin011001100101]);
-ASSERT(Y[0bin010011111101]=Y[0bin011001100101]);
-ASSERT(X[0bin010011111110]=X[0bin011010010011]);
-ASSERT(Y[0bin010011111110]=Y[0bin011010010011]);
-ASSERT(X[0bin010011111111]=X[0bin011011000001]);
-ASSERT(Y[0bin010011111111]=Y[0bin011011000001]);
-ASSERT(X[0bin010100000000]=X[0bin011011101111]);
-ASSERT(Y[0bin010100000000]=Y[0bin011011101111]);
-ASSERT(X[0bin010100000001]=X[0bin011100011101]);
-ASSERT(Y[0bin010100000001]=Y[0bin011100011101]);
-ASSERT(X[0bin010100000010]=X[0bin011101001011]);
-ASSERT(Y[0bin010100000010]=Y[0bin011101001011]);
-ASSERT(X[0bin010100000011]=X[0bin011101111001]);
-ASSERT(Y[0bin010100000011]=Y[0bin011101111001]);
-ASSERT(X[0bin010100000100]=X[0bin011110100111]);
-ASSERT(Y[0bin010100000100]=Y[0bin011110100111]);
-ASSERT(X[0bin010100000101]=X[0bin011111010101]);
-ASSERT(Y[0bin010100000101]=Y[0bin011111010101]);
-ASSERT(X[0bin010100000110]=X[0bin100000000011]);
-ASSERT(Y[0bin010100000110]=Y[0bin100000000011]);
-ASSERT(X[0bin010100000111]=X[0bin100000110001]);
-ASSERT(Y[0bin010100000111]=Y[0bin100000110001]);
-ASSERT(X[0bin010100001000]=X[0bin000000011100]);
-ASSERT(Y[0bin010100001000]=Y[0bin000000011100]);
-ASSERT(X[0bin010100001001]=X[0bin000001001010]);
-ASSERT(Y[0bin010100001001]=Y[0bin000001001010]);
-ASSERT(X[0bin010100001010]=X[0bin000001111000]);
-ASSERT(Y[0bin010100001010]=Y[0bin000001111000]);
-ASSERT(X[0bin010100001011]=X[0bin000010100110]);
-ASSERT(Y[0bin010100001011]=Y[0bin000010100110]);
-ASSERT(X[0bin010100001100]=X[0bin000011010100]);
-ASSERT(Y[0bin010100001100]=Y[0bin000011010100]);
-ASSERT(X[0bin010100001101]=X[0bin000100000010]);
-ASSERT(Y[0bin010100001101]=Y[0bin000100000010]);
-ASSERT(X[0bin010100001110]=X[0bin000100110000]);
-ASSERT(Y[0bin010100001110]=Y[0bin000100110000]);
-ASSERT(X[0bin010100001111]=X[0bin000101011110]);
-ASSERT(Y[0bin010100001111]=Y[0bin000101011110]);
-ASSERT(X[0bin010100010000]=X[0bin000110001100]);
-ASSERT(Y[0bin010100010000]=Y[0bin000110001100]);
-ASSERT(X[0bin010100010001]=X[0bin000110111010]);
-ASSERT(Y[0bin010100010001]=Y[0bin000110111010]);
-ASSERT(X[0bin010100010010]=X[0bin000111101000]);
-ASSERT(Y[0bin010100010010]=Y[0bin000111101000]);
-ASSERT(X[0bin010100010011]=X[0bin001000010110]);
-ASSERT(Y[0bin010100010011]=Y[0bin001000010110]);
-ASSERT(X[0bin010100010100]=X[0bin001001000100]);
-ASSERT(Y[0bin010100010100]=Y[0bin001001000100]);
-ASSERT(X[0bin010100010101]=X[0bin001001110010]);
-ASSERT(Y[0bin010100010101]=Y[0bin001001110010]);
-ASSERT(X[0bin010100010110]=X[0bin001010100000]);
-ASSERT(Y[0bin010100010110]=Y[0bin001010100000]);
-ASSERT(X[0bin010100010111]=X[0bin001011001110]);
-ASSERT(Y[0bin010100010111]=Y[0bin001011001110]);
-ASSERT(X[0bin010100011000]=X[0bin001011111100]);
-ASSERT(Y[0bin010100011000]=Y[0bin001011111100]);
-ASSERT(X[0bin010100011001]=X[0bin001100101010]);
-ASSERT(Y[0bin010100011001]=Y[0bin001100101010]);
-ASSERT(X[0bin010100011010]=X[0bin001101011000]);
-ASSERT(Y[0bin010100011010]=Y[0bin001101011000]);
-ASSERT(X[0bin010100011011]=X[0bin001110000110]);
-ASSERT(Y[0bin010100011011]=Y[0bin001110000110]);
-ASSERT(X[0bin010100011100]=X[0bin001110110100]);
-ASSERT(Y[0bin010100011100]=Y[0bin001110110100]);
-ASSERT(X[0bin010100011101]=X[0bin001111100010]);
-ASSERT(Y[0bin010100011101]=Y[0bin001111100010]);
-ASSERT(X[0bin010100011110]=X[0bin010000010000]);
-ASSERT(Y[0bin010100011110]=Y[0bin010000010000]);
-ASSERT(X[0bin010100011111]=X[0bin010000111110]);
-ASSERT(Y[0bin010100011111]=Y[0bin010000111110]);
-ASSERT(X[0bin010100100000]=X[0bin010001101100]);
-ASSERT(Y[0bin010100100000]=Y[0bin010001101100]);
-ASSERT(X[0bin010100100001]=X[0bin010010011010]);
-ASSERT(Y[0bin010100100001]=Y[0bin010010011010]);
-ASSERT(X[0bin010100100010]=X[0bin010011001000]);
-ASSERT(Y[0bin010100100010]=Y[0bin010011001000]);
-ASSERT(X[0bin010100100011]=X[0bin010011110110]);
-ASSERT(Y[0bin010100100011]=Y[0bin010011110110]);
-ASSERT(X[0bin010100100100]=X[0bin010100100100]);
-ASSERT(Y[0bin010100100100]=Y[0bin010100100100]);
-ASSERT(X[0bin010100100101]=X[0bin010101010010]);
-ASSERT(Y[0bin010100100101]=Y[0bin010101010010]);
-ASSERT(X[0bin010100100110]=X[0bin010110000000]);
-ASSERT(Y[0bin010100100110]=Y[0bin010110000000]);
-ASSERT(X[0bin010100100111]=X[0bin010110101110]);
-ASSERT(Y[0bin010100100111]=Y[0bin010110101110]);
-ASSERT(X[0bin010100101000]=X[0bin010111011100]);
-ASSERT(Y[0bin010100101000]=Y[0bin010111011100]);
-ASSERT(X[0bin010100101001]=X[0bin011000001010]);
-ASSERT(Y[0bin010100101001]=Y[0bin011000001010]);
-ASSERT(X[0bin010100101010]=X[0bin011000111000]);
-ASSERT(Y[0bin010100101010]=Y[0bin011000111000]);
-ASSERT(X[0bin010100101011]=X[0bin011001100110]);
-ASSERT(Y[0bin010100101011]=Y[0bin011001100110]);
-ASSERT(X[0bin010100101100]=X[0bin011010010100]);
-ASSERT(Y[0bin010100101100]=Y[0bin011010010100]);
-ASSERT(X[0bin010100101101]=X[0bin011011000010]);
-ASSERT(Y[0bin010100101101]=Y[0bin011011000010]);
-ASSERT(X[0bin010100101110]=X[0bin011011110000]);
-ASSERT(Y[0bin010100101110]=Y[0bin011011110000]);
-ASSERT(X[0bin010100101111]=X[0bin011100011110]);
-ASSERT(Y[0bin010100101111]=Y[0bin011100011110]);
-ASSERT(X[0bin010100110000]=X[0bin011101001100]);
-ASSERT(Y[0bin010100110000]=Y[0bin011101001100]);
-ASSERT(X[0bin010100110001]=X[0bin011101111010]);
-ASSERT(Y[0bin010100110001]=Y[0bin011101111010]);
-ASSERT(X[0bin010100110010]=X[0bin011110101000]);
-ASSERT(Y[0bin010100110010]=Y[0bin011110101000]);
-ASSERT(X[0bin010100110011]=X[0bin011111010110]);
-ASSERT(Y[0bin010100110011]=Y[0bin011111010110]);
-ASSERT(X[0bin010100110100]=X[0bin100000000100]);
-ASSERT(Y[0bin010100110100]=Y[0bin100000000100]);
-ASSERT(X[0bin010100110101]=X[0bin100000110010]);
-ASSERT(Y[0bin010100110101]=Y[0bin100000110010]);
-ASSERT(X[0bin010100110110]=X[0bin000000011101]);
-ASSERT(Y[0bin010100110110]=Y[0bin000000011101]);
-ASSERT(X[0bin010100110111]=X[0bin000001001011]);
-ASSERT(Y[0bin010100110111]=Y[0bin000001001011]);
-ASSERT(X[0bin010100111000]=X[0bin000001111001]);
-ASSERT(Y[0bin010100111000]=Y[0bin000001111001]);
-ASSERT(X[0bin010100111001]=X[0bin000010100111]);
-ASSERT(Y[0bin010100111001]=Y[0bin000010100111]);
-ASSERT(X[0bin010100111010]=X[0bin000011010101]);
-ASSERT(Y[0bin010100111010]=Y[0bin000011010101]);
-ASSERT(X[0bin010100111011]=X[0bin000100000011]);
-ASSERT(Y[0bin010100111011]=Y[0bin000100000011]);
-ASSERT(X[0bin010100111100]=X[0bin000100110001]);
-ASSERT(Y[0bin010100111100]=Y[0bin000100110001]);
-ASSERT(X[0bin010100111101]=X[0bin000101011111]);
-ASSERT(Y[0bin010100111101]=Y[0bin000101011111]);
-ASSERT(X[0bin010100111110]=X[0bin000110001101]);
-ASSERT(Y[0bin010100111110]=Y[0bin000110001101]);
-ASSERT(X[0bin010100111111]=X[0bin000110111011]);
-ASSERT(Y[0bin010100111111]=Y[0bin000110111011]);
-ASSERT(X[0bin010101000000]=X[0bin000111101001]);
-ASSERT(Y[0bin010101000000]=Y[0bin000111101001]);
-ASSERT(X[0bin010101000001]=X[0bin001000010111]);
-ASSERT(Y[0bin010101000001]=Y[0bin001000010111]);
-ASSERT(X[0bin010101000010]=X[0bin001001000101]);
-ASSERT(Y[0bin010101000010]=Y[0bin001001000101]);
-ASSERT(X[0bin010101000011]=X[0bin001001110011]);
-ASSERT(Y[0bin010101000011]=Y[0bin001001110011]);
-ASSERT(X[0bin010101000100]=X[0bin001010100001]);
-ASSERT(Y[0bin010101000100]=Y[0bin001010100001]);
-ASSERT(X[0bin010101000101]=X[0bin001011001111]);
-ASSERT(Y[0bin010101000101]=Y[0bin001011001111]);
-ASSERT(X[0bin010101000110]=X[0bin001011111101]);
-ASSERT(Y[0bin010101000110]=Y[0bin001011111101]);
-ASSERT(X[0bin010101000111]=X[0bin001100101011]);
-ASSERT(Y[0bin010101000111]=Y[0bin001100101011]);
-ASSERT(X[0bin010101001000]=X[0bin001101011001]);
-ASSERT(Y[0bin010101001000]=Y[0bin001101011001]);
-ASSERT(X[0bin010101001001]=X[0bin001110000111]);
-ASSERT(Y[0bin010101001001]=Y[0bin001110000111]);
-ASSERT(X[0bin010101001010]=X[0bin001110110101]);
-ASSERT(Y[0bin010101001010]=Y[0bin001110110101]);
-ASSERT(X[0bin010101001011]=X[0bin001111100011]);
-ASSERT(Y[0bin010101001011]=Y[0bin001111100011]);
-ASSERT(X[0bin010101001100]=X[0bin010000010001]);
-ASSERT(Y[0bin010101001100]=Y[0bin010000010001]);
-ASSERT(X[0bin010101001101]=X[0bin010000111111]);
-ASSERT(Y[0bin010101001101]=Y[0bin010000111111]);
-ASSERT(X[0bin010101001110]=X[0bin010001101101]);
-ASSERT(Y[0bin010101001110]=Y[0bin010001101101]);
-ASSERT(X[0bin010101001111]=X[0bin010010011011]);
-ASSERT(Y[0bin010101001111]=Y[0bin010010011011]);
-ASSERT(X[0bin010101010000]=X[0bin010011001001]);
-ASSERT(Y[0bin010101010000]=Y[0bin010011001001]);
-ASSERT(X[0bin010101010001]=X[0bin010011110111]);
-ASSERT(Y[0bin010101010001]=Y[0bin010011110111]);
-ASSERT(X[0bin010101010010]=X[0bin010100100101]);
-ASSERT(Y[0bin010101010010]=Y[0bin010100100101]);
-ASSERT(X[0bin010101010011]=X[0bin010101010011]);
-ASSERT(Y[0bin010101010011]=Y[0bin010101010011]);
-ASSERT(X[0bin010101010100]=X[0bin010110000001]);
-ASSERT(Y[0bin010101010100]=Y[0bin010110000001]);
-ASSERT(X[0bin010101010101]=X[0bin010110101111]);
-ASSERT(Y[0bin010101010101]=Y[0bin010110101111]);
-ASSERT(X[0bin010101010110]=X[0bin010111011101]);
-ASSERT(Y[0bin010101010110]=Y[0bin010111011101]);
-ASSERT(X[0bin010101010111]=X[0bin011000001011]);
-ASSERT(Y[0bin010101010111]=Y[0bin011000001011]);
-ASSERT(X[0bin010101011000]=X[0bin011000111001]);
-ASSERT(Y[0bin010101011000]=Y[0bin011000111001]);
-ASSERT(X[0bin010101011001]=X[0bin011001100111]);
-ASSERT(Y[0bin010101011001]=Y[0bin011001100111]);
-ASSERT(X[0bin010101011010]=X[0bin011010010101]);
-ASSERT(Y[0bin010101011010]=Y[0bin011010010101]);
-ASSERT(X[0bin010101011011]=X[0bin011011000011]);
-ASSERT(Y[0bin010101011011]=Y[0bin011011000011]);
-ASSERT(X[0bin010101011100]=X[0bin011011110001]);
-ASSERT(Y[0bin010101011100]=Y[0bin011011110001]);
-ASSERT(X[0bin010101011101]=X[0bin011100011111]);
-ASSERT(Y[0bin010101011101]=Y[0bin011100011111]);
-ASSERT(X[0bin010101011110]=X[0bin011101001101]);
-ASSERT(Y[0bin010101011110]=Y[0bin011101001101]);
-ASSERT(X[0bin010101011111]=X[0bin011101111011]);
-ASSERT(Y[0bin010101011111]=Y[0bin011101111011]);
-ASSERT(X[0bin010101100000]=X[0bin011110101001]);
-ASSERT(Y[0bin010101100000]=Y[0bin011110101001]);
-ASSERT(X[0bin010101100001]=X[0bin011111010111]);
-ASSERT(Y[0bin010101100001]=Y[0bin011111010111]);
-ASSERT(X[0bin010101100010]=X[0bin100000000101]);
-ASSERT(Y[0bin010101100010]=Y[0bin100000000101]);
-ASSERT(X[0bin010101100011]=X[0bin100000110011]);
-ASSERT(Y[0bin010101100011]=Y[0bin100000110011]);
-ASSERT(X[0bin010101100100]=X[0bin000000011110]);
-ASSERT(Y[0bin010101100100]=Y[0bin000000011110]);
-ASSERT(X[0bin010101100101]=X[0bin000001001100]);
-ASSERT(Y[0bin010101100101]=Y[0bin000001001100]);
-ASSERT(X[0bin010101100110]=X[0bin000001111010]);
-ASSERT(Y[0bin010101100110]=Y[0bin000001111010]);
-ASSERT(X[0bin010101100111]=X[0bin000010101000]);
-ASSERT(Y[0bin010101100111]=Y[0bin000010101000]);
-ASSERT(X[0bin010101101000]=X[0bin000011010110]);
-ASSERT(Y[0bin010101101000]=Y[0bin000011010110]);
-ASSERT(X[0bin010101101001]=X[0bin000100000100]);
-ASSERT(Y[0bin010101101001]=Y[0bin000100000100]);
-ASSERT(X[0bin010101101010]=X[0bin000100110010]);
-ASSERT(Y[0bin010101101010]=Y[0bin000100110010]);
-ASSERT(X[0bin010101101011]=X[0bin000101100000]);
-ASSERT(Y[0bin010101101011]=Y[0bin000101100000]);
-ASSERT(X[0bin010101101100]=X[0bin000110001110]);
-ASSERT(Y[0bin010101101100]=Y[0bin000110001110]);
-ASSERT(X[0bin010101101101]=X[0bin000110111100]);
-ASSERT(Y[0bin010101101101]=Y[0bin000110111100]);
-ASSERT(X[0bin010101101110]=X[0bin000111101010]);
-ASSERT(Y[0bin010101101110]=Y[0bin000111101010]);
-ASSERT(X[0bin010101101111]=X[0bin001000011000]);
-ASSERT(Y[0bin010101101111]=Y[0bin001000011000]);
-ASSERT(X[0bin010101110000]=X[0bin001001000110]);
-ASSERT(Y[0bin010101110000]=Y[0bin001001000110]);
-ASSERT(X[0bin010101110001]=X[0bin001001110100]);
-ASSERT(Y[0bin010101110001]=Y[0bin001001110100]);
-ASSERT(X[0bin010101110010]=X[0bin001010100010]);
-ASSERT(Y[0bin010101110010]=Y[0bin001010100010]);
-ASSERT(X[0bin010101110011]=X[0bin001011010000]);
-ASSERT(Y[0bin010101110011]=Y[0bin001011010000]);
-ASSERT(X[0bin010101110100]=X[0bin001011111110]);
-ASSERT(Y[0bin010101110100]=Y[0bin001011111110]);
-ASSERT(X[0bin010101110101]=X[0bin001100101100]);
-ASSERT(Y[0bin010101110101]=Y[0bin001100101100]);
-ASSERT(X[0bin010101110110]=X[0bin001101011010]);
-ASSERT(Y[0bin010101110110]=Y[0bin001101011010]);
-ASSERT(X[0bin010101110111]=X[0bin001110001000]);
-ASSERT(Y[0bin010101110111]=Y[0bin001110001000]);
-ASSERT(X[0bin010101111000]=X[0bin001110110110]);
-ASSERT(Y[0bin010101111000]=Y[0bin001110110110]);
-ASSERT(X[0bin010101111001]=X[0bin001111100100]);
-ASSERT(Y[0bin010101111001]=Y[0bin001111100100]);
-ASSERT(X[0bin010101111010]=X[0bin010000010010]);
-ASSERT(Y[0bin010101111010]=Y[0bin010000010010]);
-ASSERT(X[0bin010101111011]=X[0bin010001000000]);
-ASSERT(Y[0bin010101111011]=Y[0bin010001000000]);
-ASSERT(X[0bin010101111100]=X[0bin010001101110]);
-ASSERT(Y[0bin010101111100]=Y[0bin010001101110]);
-ASSERT(X[0bin010101111101]=X[0bin010010011100]);
-ASSERT(Y[0bin010101111101]=Y[0bin010010011100]);
-ASSERT(X[0bin010101111110]=X[0bin010011001010]);
-ASSERT(Y[0bin010101111110]=Y[0bin010011001010]);
-ASSERT(X[0bin010101111111]=X[0bin010011111000]);
-ASSERT(Y[0bin010101111111]=Y[0bin010011111000]);
-ASSERT(X[0bin010110000000]=X[0bin010100100110]);
-ASSERT(Y[0bin010110000000]=Y[0bin010100100110]);
-ASSERT(X[0bin010110000001]=X[0bin010101010100]);
-ASSERT(Y[0bin010110000001]=Y[0bin010101010100]);
-ASSERT(X[0bin010110000010]=X[0bin010110000010]);
-ASSERT(Y[0bin010110000010]=Y[0bin010110000010]);
-ASSERT(X[0bin010110000011]=X[0bin010110110000]);
-ASSERT(Y[0bin010110000011]=Y[0bin010110110000]);
-ASSERT(X[0bin010110000100]=X[0bin010111011110]);
-ASSERT(Y[0bin010110000100]=Y[0bin010111011110]);
-ASSERT(X[0bin010110000101]=X[0bin011000001100]);
-ASSERT(Y[0bin010110000101]=Y[0bin011000001100]);
-ASSERT(X[0bin010110000110]=X[0bin011000111010]);
-ASSERT(Y[0bin010110000110]=Y[0bin011000111010]);
-ASSERT(X[0bin010110000111]=X[0bin011001101000]);
-ASSERT(Y[0bin010110000111]=Y[0bin011001101000]);
-ASSERT(X[0bin010110001000]=X[0bin011010010110]);
-ASSERT(Y[0bin010110001000]=Y[0bin011010010110]);
-ASSERT(X[0bin010110001001]=X[0bin011011000100]);
-ASSERT(Y[0bin010110001001]=Y[0bin011011000100]);
-ASSERT(X[0bin010110001010]=X[0bin011011110010]);
-ASSERT(Y[0bin010110001010]=Y[0bin011011110010]);
-ASSERT(X[0bin010110001011]=X[0bin011100100000]);
-ASSERT(Y[0bin010110001011]=Y[0bin011100100000]);
-ASSERT(X[0bin010110001100]=X[0bin011101001110]);
-ASSERT(Y[0bin010110001100]=Y[0bin011101001110]);
-ASSERT(X[0bin010110001101]=X[0bin011101111100]);
-ASSERT(Y[0bin010110001101]=Y[0bin011101111100]);
-ASSERT(X[0bin010110001110]=X[0bin011110101010]);
-ASSERT(Y[0bin010110001110]=Y[0bin011110101010]);
-ASSERT(X[0bin010110001111]=X[0bin011111011000]);
-ASSERT(Y[0bin010110001111]=Y[0bin011111011000]);
-ASSERT(X[0bin010110010000]=X[0bin100000000110]);
-ASSERT(Y[0bin010110010000]=Y[0bin100000000110]);
-ASSERT(X[0bin010110010001]=X[0bin100000110100]);
-ASSERT(Y[0bin010110010001]=Y[0bin100000110100]);
-ASSERT(X[0bin010110010010]=X[0bin000000011111]);
-ASSERT(Y[0bin010110010010]=Y[0bin000000011111]);
-ASSERT(X[0bin010110010011]=X[0bin000001001101]);
-ASSERT(Y[0bin010110010011]=Y[0bin000001001101]);
-ASSERT(X[0bin010110010100]=X[0bin000001111011]);
-ASSERT(Y[0bin010110010100]=Y[0bin000001111011]);
-ASSERT(X[0bin010110010101]=X[0bin000010101001]);
-ASSERT(Y[0bin010110010101]=Y[0bin000010101001]);
-ASSERT(X[0bin010110010110]=X[0bin000011010111]);
-ASSERT(Y[0bin010110010110]=Y[0bin000011010111]);
-ASSERT(X[0bin010110010111]=X[0bin000100000101]);
-ASSERT(Y[0bin010110010111]=Y[0bin000100000101]);
-ASSERT(X[0bin010110011000]=X[0bin000100110011]);
-ASSERT(Y[0bin010110011000]=Y[0bin000100110011]);
-ASSERT(X[0bin010110011001]=X[0bin000101100001]);
-ASSERT(Y[0bin010110011001]=Y[0bin000101100001]);
-ASSERT(X[0bin010110011010]=X[0bin000110001111]);
-ASSERT(Y[0bin010110011010]=Y[0bin000110001111]);
-ASSERT(X[0bin010110011011]=X[0bin000110111101]);
-ASSERT(Y[0bin010110011011]=Y[0bin000110111101]);
-ASSERT(X[0bin010110011100]=X[0bin000111101011]);
-ASSERT(Y[0bin010110011100]=Y[0bin000111101011]);
-ASSERT(X[0bin010110011101]=X[0bin001000011001]);
-ASSERT(Y[0bin010110011101]=Y[0bin001000011001]);
-ASSERT(X[0bin010110011110]=X[0bin001001000111]);
-ASSERT(Y[0bin010110011110]=Y[0bin001001000111]);
-ASSERT(X[0bin010110011111]=X[0bin001001110101]);
-ASSERT(Y[0bin010110011111]=Y[0bin001001110101]);
-ASSERT(X[0bin010110100000]=X[0bin001010100011]);
-ASSERT(Y[0bin010110100000]=Y[0bin001010100011]);
-ASSERT(X[0bin010110100001]=X[0bin001011010001]);
-ASSERT(Y[0bin010110100001]=Y[0bin001011010001]);
-ASSERT(X[0bin010110100010]=X[0bin001011111111]);
-ASSERT(Y[0bin010110100010]=Y[0bin001011111111]);
-ASSERT(X[0bin010110100011]=X[0bin001100101101]);
-ASSERT(Y[0bin010110100011]=Y[0bin001100101101]);
-ASSERT(X[0bin010110100100]=X[0bin001101011011]);
-ASSERT(Y[0bin010110100100]=Y[0bin001101011011]);
-ASSERT(X[0bin010110100101]=X[0bin001110001001]);
-ASSERT(Y[0bin010110100101]=Y[0bin001110001001]);
-ASSERT(X[0bin010110100110]=X[0bin001110110111]);
-ASSERT(Y[0bin010110100110]=Y[0bin001110110111]);
-ASSERT(X[0bin010110100111]=X[0bin001111100101]);
-ASSERT(Y[0bin010110100111]=Y[0bin001111100101]);
-ASSERT(X[0bin010110101000]=X[0bin010000010011]);
-ASSERT(Y[0bin010110101000]=Y[0bin010000010011]);
-ASSERT(X[0bin010110101001]=X[0bin010001000001]);
-ASSERT(Y[0bin010110101001]=Y[0bin010001000001]);
-ASSERT(X[0bin010110101010]=X[0bin010001101111]);
-ASSERT(Y[0bin010110101010]=Y[0bin010001101111]);
-ASSERT(X[0bin010110101011]=X[0bin010010011101]);
-ASSERT(Y[0bin010110101011]=Y[0bin010010011101]);
-ASSERT(X[0bin010110101100]=X[0bin010011001011]);
-ASSERT(Y[0bin010110101100]=Y[0bin010011001011]);
-ASSERT(X[0bin010110101101]=X[0bin010011111001]);
-ASSERT(Y[0bin010110101101]=Y[0bin010011111001]);
-ASSERT(X[0bin010110101110]=X[0bin010100100111]);
-ASSERT(Y[0bin010110101110]=Y[0bin010100100111]);
-ASSERT(X[0bin010110101111]=X[0bin010101010101]);
-ASSERT(Y[0bin010110101111]=Y[0bin010101010101]);
-ASSERT(X[0bin010110110000]=X[0bin010110000011]);
-ASSERT(Y[0bin010110110000]=Y[0bin010110000011]);
-ASSERT(X[0bin010110110001]=X[0bin010110110001]);
-ASSERT(Y[0bin010110110001]=Y[0bin010110110001]);
-ASSERT(X[0bin010110110010]=X[0bin010111011111]);
-ASSERT(Y[0bin010110110010]=Y[0bin010111011111]);
-ASSERT(X[0bin010110110011]=X[0bin011000001101]);
-ASSERT(Y[0bin010110110011]=Y[0bin011000001101]);
-ASSERT(X[0bin010110110100]=X[0bin011000111011]);
-ASSERT(Y[0bin010110110100]=Y[0bin011000111011]);
-ASSERT(X[0bin010110110101]=X[0bin011001101001]);
-ASSERT(Y[0bin010110110101]=Y[0bin011001101001]);
-ASSERT(X[0bin010110110110]=X[0bin011010010111]);
-ASSERT(Y[0bin010110110110]=Y[0bin011010010111]);
-ASSERT(X[0bin010110110111]=X[0bin011011000101]);
-ASSERT(Y[0bin010110110111]=Y[0bin011011000101]);
-ASSERT(X[0bin010110111000]=X[0bin011011110011]);
-ASSERT(Y[0bin010110111000]=Y[0bin011011110011]);
-ASSERT(X[0bin010110111001]=X[0bin011100100001]);
-ASSERT(Y[0bin010110111001]=Y[0bin011100100001]);
-ASSERT(X[0bin010110111010]=X[0bin011101001111]);
-ASSERT(Y[0bin010110111010]=Y[0bin011101001111]);
-ASSERT(X[0bin010110111011]=X[0bin011101111101]);
-ASSERT(Y[0bin010110111011]=Y[0bin011101111101]);
-ASSERT(X[0bin010110111100]=X[0bin011110101011]);
-ASSERT(Y[0bin010110111100]=Y[0bin011110101011]);
-ASSERT(X[0bin010110111101]=X[0bin011111011001]);
-ASSERT(Y[0bin010110111101]=Y[0bin011111011001]);
-ASSERT(X[0bin010110111110]=X[0bin100000000111]);
-ASSERT(Y[0bin010110111110]=Y[0bin100000000111]);
-ASSERT(X[0bin010110111111]=X[0bin100000110101]);
-ASSERT(Y[0bin010110111111]=Y[0bin100000110101]);
-ASSERT(X[0bin010111000000]=X[0bin000000100000]);
-ASSERT(Y[0bin010111000000]=Y[0bin000000100000]);
-ASSERT(X[0bin010111000001]=X[0bin000001001110]);
-ASSERT(Y[0bin010111000001]=Y[0bin000001001110]);
-ASSERT(X[0bin010111000010]=X[0bin000001111100]);
-ASSERT(Y[0bin010111000010]=Y[0bin000001111100]);
-ASSERT(X[0bin010111000011]=X[0bin000010101010]);
-ASSERT(Y[0bin010111000011]=Y[0bin000010101010]);
-ASSERT(X[0bin010111000100]=X[0bin000011011000]);
-ASSERT(Y[0bin010111000100]=Y[0bin000011011000]);
-ASSERT(X[0bin010111000101]=X[0bin000100000110]);
-ASSERT(Y[0bin010111000101]=Y[0bin000100000110]);
-ASSERT(X[0bin010111000110]=X[0bin000100110100]);
-ASSERT(Y[0bin010111000110]=Y[0bin000100110100]);
-ASSERT(X[0bin010111000111]=X[0bin000101100010]);
-ASSERT(Y[0bin010111000111]=Y[0bin000101100010]);
-ASSERT(X[0bin010111001000]=X[0bin000110010000]);
-ASSERT(Y[0bin010111001000]=Y[0bin000110010000]);
-ASSERT(X[0bin010111001001]=X[0bin000110111110]);
-ASSERT(Y[0bin010111001001]=Y[0bin000110111110]);
-ASSERT(X[0bin010111001010]=X[0bin000111101100]);
-ASSERT(Y[0bin010111001010]=Y[0bin000111101100]);
-ASSERT(X[0bin010111001011]=X[0bin001000011010]);
-ASSERT(Y[0bin010111001011]=Y[0bin001000011010]);
-ASSERT(X[0bin010111001100]=X[0bin001001001000]);
-ASSERT(Y[0bin010111001100]=Y[0bin001001001000]);
-ASSERT(X[0bin010111001101]=X[0bin001001110110]);
-ASSERT(Y[0bin010111001101]=Y[0bin001001110110]);
-ASSERT(X[0bin010111001110]=X[0bin001010100100]);
-ASSERT(Y[0bin010111001110]=Y[0bin001010100100]);
-ASSERT(X[0bin010111001111]=X[0bin001011010010]);
-ASSERT(Y[0bin010111001111]=Y[0bin001011010010]);
-ASSERT(X[0bin010111010000]=X[0bin001100000000]);
-ASSERT(Y[0bin010111010000]=Y[0bin001100000000]);
-ASSERT(X[0bin010111010001]=X[0bin001100101110]);
-ASSERT(Y[0bin010111010001]=Y[0bin001100101110]);
-ASSERT(X[0bin010111010010]=X[0bin001101011100]);
-ASSERT(Y[0bin010111010010]=Y[0bin001101011100]);
-ASSERT(X[0bin010111010011]=X[0bin001110001010]);
-ASSERT(Y[0bin010111010011]=Y[0bin001110001010]);
-ASSERT(X[0bin010111010100]=X[0bin001110111000]);
-ASSERT(Y[0bin010111010100]=Y[0bin001110111000]);
-ASSERT(X[0bin010111010101]=X[0bin001111100110]);
-ASSERT(Y[0bin010111010101]=Y[0bin001111100110]);
-ASSERT(X[0bin010111010110]=X[0bin010000010100]);
-ASSERT(Y[0bin010111010110]=Y[0bin010000010100]);
-ASSERT(X[0bin010111010111]=X[0bin010001000010]);
-ASSERT(Y[0bin010111010111]=Y[0bin010001000010]);
-ASSERT(X[0bin010111011000]=X[0bin010001110000]);
-ASSERT(Y[0bin010111011000]=Y[0bin010001110000]);
-ASSERT(X[0bin010111011001]=X[0bin010010011110]);
-ASSERT(Y[0bin010111011001]=Y[0bin010010011110]);
-ASSERT(X[0bin010111011010]=X[0bin010011001100]);
-ASSERT(Y[0bin010111011010]=Y[0bin010011001100]);
-ASSERT(X[0bin010111011011]=X[0bin010011111010]);
-ASSERT(Y[0bin010111011011]=Y[0bin010011111010]);
-ASSERT(X[0bin010111011100]=X[0bin010100101000]);
-ASSERT(Y[0bin010111011100]=Y[0bin010100101000]);
-ASSERT(X[0bin010111011101]=X[0bin010101010110]);
-ASSERT(Y[0bin010111011101]=Y[0bin010101010110]);
-ASSERT(X[0bin010111011110]=X[0bin010110000100]);
-ASSERT(Y[0bin010111011110]=Y[0bin010110000100]);
-ASSERT(X[0bin010111011111]=X[0bin010110110010]);
-ASSERT(Y[0bin010111011111]=Y[0bin010110110010]);
-ASSERT(X[0bin010111100000]=X[0bin010111100000]);
-ASSERT(Y[0bin010111100000]=Y[0bin010111100000]);
-ASSERT(X[0bin010111100001]=X[0bin011000001110]);
-ASSERT(Y[0bin010111100001]=Y[0bin011000001110]);
-ASSERT(X[0bin010111100010]=X[0bin011000111100]);
-ASSERT(Y[0bin010111100010]=Y[0bin011000111100]);
-ASSERT(X[0bin010111100011]=X[0bin011001101010]);
-ASSERT(Y[0bin010111100011]=Y[0bin011001101010]);
-ASSERT(X[0bin010111100100]=X[0bin011010011000]);
-ASSERT(Y[0bin010111100100]=Y[0bin011010011000]);
-ASSERT(X[0bin010111100101]=X[0bin011011000110]);
-ASSERT(Y[0bin010111100101]=Y[0bin011011000110]);
-ASSERT(X[0bin010111100110]=X[0bin011011110100]);
-ASSERT(Y[0bin010111100110]=Y[0bin011011110100]);
-ASSERT(X[0bin010111100111]=X[0bin011100100010]);
-ASSERT(Y[0bin010111100111]=Y[0bin011100100010]);
-ASSERT(X[0bin010111101000]=X[0bin011101010000]);
-ASSERT(Y[0bin010111101000]=Y[0bin011101010000]);
-ASSERT(X[0bin010111101001]=X[0bin011101111110]);
-ASSERT(Y[0bin010111101001]=Y[0bin011101111110]);
-ASSERT(X[0bin010111101010]=X[0bin011110101100]);
-ASSERT(Y[0bin010111101010]=Y[0bin011110101100]);
-ASSERT(X[0bin010111101011]=X[0bin011111011010]);
-ASSERT(Y[0bin010111101011]=Y[0bin011111011010]);
-ASSERT(X[0bin010111101100]=X[0bin100000001000]);
-ASSERT(Y[0bin010111101100]=Y[0bin100000001000]);
-ASSERT(X[0bin010111101101]=X[0bin100000110110]);
-ASSERT(Y[0bin010111101101]=Y[0bin100000110110]);
-ASSERT(X[0bin010111101110]=X[0bin000000100001]);
-ASSERT(Y[0bin010111101110]=Y[0bin000000100001]);
-ASSERT(X[0bin010111101111]=X[0bin000001001111]);
-ASSERT(Y[0bin010111101111]=Y[0bin000001001111]);
-ASSERT(X[0bin010111110000]=X[0bin000001111101]);
-ASSERT(Y[0bin010111110000]=Y[0bin000001111101]);
-ASSERT(X[0bin010111110001]=X[0bin000010101011]);
-ASSERT(Y[0bin010111110001]=Y[0bin000010101011]);
-ASSERT(X[0bin010111110010]=X[0bin000011011001]);
-ASSERT(Y[0bin010111110010]=Y[0bin000011011001]);
-ASSERT(X[0bin010111110011]=X[0bin000100000111]);
-ASSERT(Y[0bin010111110011]=Y[0bin000100000111]);
-ASSERT(X[0bin010111110100]=X[0bin000100110101]);
-ASSERT(Y[0bin010111110100]=Y[0bin000100110101]);
-ASSERT(X[0bin010111110101]=X[0bin000101100011]);
-ASSERT(Y[0bin010111110101]=Y[0bin000101100011]);
-ASSERT(X[0bin010111110110]=X[0bin000110010001]);
-ASSERT(Y[0bin010111110110]=Y[0bin000110010001]);
-ASSERT(X[0bin010111110111]=X[0bin000110111111]);
-ASSERT(Y[0bin010111110111]=Y[0bin000110111111]);
-ASSERT(X[0bin010111111000]=X[0bin000111101101]);
-ASSERT(Y[0bin010111111000]=Y[0bin000111101101]);
-ASSERT(X[0bin010111111001]=X[0bin001000011011]);
-ASSERT(Y[0bin010111111001]=Y[0bin001000011011]);
-ASSERT(X[0bin010111111010]=X[0bin001001001001]);
-ASSERT(Y[0bin010111111010]=Y[0bin001001001001]);
-ASSERT(X[0bin010111111011]=X[0bin001001110111]);
-ASSERT(Y[0bin010111111011]=Y[0bin001001110111]);
-ASSERT(X[0bin010111111100]=X[0bin001010100101]);
-ASSERT(Y[0bin010111111100]=Y[0bin001010100101]);
-ASSERT(X[0bin010111111101]=X[0bin001011010011]);
-ASSERT(Y[0bin010111111101]=Y[0bin001011010011]);
-ASSERT(X[0bin010111111110]=X[0bin001100000001]);
-ASSERT(Y[0bin010111111110]=Y[0bin001100000001]);
-ASSERT(X[0bin010111111111]=X[0bin001100101111]);
-ASSERT(Y[0bin010111111111]=Y[0bin001100101111]);
-ASSERT(X[0bin011000000000]=X[0bin001101011101]);
-ASSERT(Y[0bin011000000000]=Y[0bin001101011101]);
-ASSERT(X[0bin011000000001]=X[0bin001110001011]);
-ASSERT(Y[0bin011000000001]=Y[0bin001110001011]);
-ASSERT(X[0bin011000000010]=X[0bin001110111001]);
-ASSERT(Y[0bin011000000010]=Y[0bin001110111001]);
-ASSERT(X[0bin011000000011]=X[0bin001111100111]);
-ASSERT(Y[0bin011000000011]=Y[0bin001111100111]);
-ASSERT(X[0bin011000000100]=X[0bin010000010101]);
-ASSERT(Y[0bin011000000100]=Y[0bin010000010101]);
-ASSERT(X[0bin011000000101]=X[0bin010001000011]);
-ASSERT(Y[0bin011000000101]=Y[0bin010001000011]);
-ASSERT(X[0bin011000000110]=X[0bin010001110001]);
-ASSERT(Y[0bin011000000110]=Y[0bin010001110001]);
-ASSERT(X[0bin011000000111]=X[0bin010010011111]);
-ASSERT(Y[0bin011000000111]=Y[0bin010010011111]);
-ASSERT(X[0bin011000001000]=X[0bin010011001101]);
-ASSERT(Y[0bin011000001000]=Y[0bin010011001101]);
-ASSERT(X[0bin011000001001]=X[0bin010011111011]);
-ASSERT(Y[0bin011000001001]=Y[0bin010011111011]);
-ASSERT(X[0bin011000001010]=X[0bin010100101001]);
-ASSERT(Y[0bin011000001010]=Y[0bin010100101001]);
-ASSERT(X[0bin011000001011]=X[0bin010101010111]);
-ASSERT(Y[0bin011000001011]=Y[0bin010101010111]);
-ASSERT(X[0bin011000001100]=X[0bin010110000101]);
-ASSERT(Y[0bin011000001100]=Y[0bin010110000101]);
-ASSERT(X[0bin011000001101]=X[0bin010110110011]);
-ASSERT(Y[0bin011000001101]=Y[0bin010110110011]);
-ASSERT(X[0bin011000001110]=X[0bin010111100001]);
-ASSERT(Y[0bin011000001110]=Y[0bin010111100001]);
-ASSERT(X[0bin011000001111]=X[0bin011000001111]);
-ASSERT(Y[0bin011000001111]=Y[0bin011000001111]);
-ASSERT(X[0bin011000010000]=X[0bin011000111101]);
-ASSERT(Y[0bin011000010000]=Y[0bin011000111101]);
-ASSERT(X[0bin011000010001]=X[0bin011001101011]);
-ASSERT(Y[0bin011000010001]=Y[0bin011001101011]);
-ASSERT(X[0bin011000010010]=X[0bin011010011001]);
-ASSERT(Y[0bin011000010010]=Y[0bin011010011001]);
-ASSERT(X[0bin011000010011]=X[0bin011011000111]);
-ASSERT(Y[0bin011000010011]=Y[0bin011011000111]);
-ASSERT(X[0bin011000010100]=X[0bin011011110101]);
-ASSERT(Y[0bin011000010100]=Y[0bin011011110101]);
-ASSERT(X[0bin011000010101]=X[0bin011100100011]);
-ASSERT(Y[0bin011000010101]=Y[0bin011100100011]);
-ASSERT(X[0bin011000010110]=X[0bin011101010001]);
-ASSERT(Y[0bin011000010110]=Y[0bin011101010001]);
-ASSERT(X[0bin011000010111]=X[0bin011101111111]);
-ASSERT(Y[0bin011000010111]=Y[0bin011101111111]);
-ASSERT(X[0bin011000011000]=X[0bin011110101101]);
-ASSERT(Y[0bin011000011000]=Y[0bin011110101101]);
-ASSERT(X[0bin011000011001]=X[0bin011111011011]);
-ASSERT(Y[0bin011000011001]=Y[0bin011111011011]);
-ASSERT(X[0bin011000011010]=X[0bin100000001001]);
-ASSERT(Y[0bin011000011010]=Y[0bin100000001001]);
-ASSERT(X[0bin011000011011]=X[0bin100000110111]);
-ASSERT(Y[0bin011000011011]=Y[0bin100000110111]);
-ASSERT(X[0bin011000011100]=X[0bin000000100010]);
-ASSERT(Y[0bin011000011100]=Y[0bin000000100010]);
-ASSERT(X[0bin011000011101]=X[0bin000001010000]);
-ASSERT(Y[0bin011000011101]=Y[0bin000001010000]);
-ASSERT(X[0bin011000011110]=X[0bin000001111110]);
-ASSERT(Y[0bin011000011110]=Y[0bin000001111110]);
-ASSERT(X[0bin011000011111]=X[0bin000010101100]);
-ASSERT(Y[0bin011000011111]=Y[0bin000010101100]);
-ASSERT(X[0bin011000100000]=X[0bin000011011010]);
-ASSERT(Y[0bin011000100000]=Y[0bin000011011010]);
-ASSERT(X[0bin011000100001]=X[0bin000100001000]);
-ASSERT(Y[0bin011000100001]=Y[0bin000100001000]);
-ASSERT(X[0bin011000100010]=X[0bin000100110110]);
-ASSERT(Y[0bin011000100010]=Y[0bin000100110110]);
-ASSERT(X[0bin011000100011]=X[0bin000101100100]);
-ASSERT(Y[0bin011000100011]=Y[0bin000101100100]);
-ASSERT(X[0bin011000100100]=X[0bin000110010010]);
-ASSERT(Y[0bin011000100100]=Y[0bin000110010010]);
-ASSERT(X[0bin011000100101]=X[0bin000111000000]);
-ASSERT(Y[0bin011000100101]=Y[0bin000111000000]);
-ASSERT(X[0bin011000100110]=X[0bin000111101110]);
-ASSERT(Y[0bin011000100110]=Y[0bin000111101110]);
-ASSERT(X[0bin011000100111]=X[0bin001000011100]);
-ASSERT(Y[0bin011000100111]=Y[0bin001000011100]);
-ASSERT(X[0bin011000101000]=X[0bin001001001010]);
-ASSERT(Y[0bin011000101000]=Y[0bin001001001010]);
-ASSERT(X[0bin011000101001]=X[0bin001001111000]);
-ASSERT(Y[0bin011000101001]=Y[0bin001001111000]);
-ASSERT(X[0bin011000101010]=X[0bin001010100110]);
-ASSERT(Y[0bin011000101010]=Y[0bin001010100110]);
-ASSERT(X[0bin011000101011]=X[0bin001011010100]);
-ASSERT(Y[0bin011000101011]=Y[0bin001011010100]);
-ASSERT(X[0bin011000101100]=X[0bin001100000010]);
-ASSERT(Y[0bin011000101100]=Y[0bin001100000010]);
-ASSERT(X[0bin011000101101]=X[0bin001100110000]);
-ASSERT(Y[0bin011000101101]=Y[0bin001100110000]);
-ASSERT(X[0bin011000101110]=X[0bin001101011110]);
-ASSERT(Y[0bin011000101110]=Y[0bin001101011110]);
-ASSERT(X[0bin011000101111]=X[0bin001110001100]);
-ASSERT(Y[0bin011000101111]=Y[0bin001110001100]);
-ASSERT(X[0bin011000110000]=X[0bin001110111010]);
-ASSERT(Y[0bin011000110000]=Y[0bin001110111010]);
-ASSERT(X[0bin011000110001]=X[0bin001111101000]);
-ASSERT(Y[0bin011000110001]=Y[0bin001111101000]);
-ASSERT(X[0bin011000110010]=X[0bin010000010110]);
-ASSERT(Y[0bin011000110010]=Y[0bin010000010110]);
-ASSERT(X[0bin011000110011]=X[0bin010001000100]);
-ASSERT(Y[0bin011000110011]=Y[0bin010001000100]);
-ASSERT(X[0bin011000110100]=X[0bin010001110010]);
-ASSERT(Y[0bin011000110100]=Y[0bin010001110010]);
-ASSERT(X[0bin011000110101]=X[0bin010010100000]);
-ASSERT(Y[0bin011000110101]=Y[0bin010010100000]);
-ASSERT(X[0bin011000110110]=X[0bin010011001110]);
-ASSERT(Y[0bin011000110110]=Y[0bin010011001110]);
-ASSERT(X[0bin011000110111]=X[0bin010011111100]);
-ASSERT(Y[0bin011000110111]=Y[0bin010011111100]);
-ASSERT(X[0bin011000111000]=X[0bin010100101010]);
-ASSERT(Y[0bin011000111000]=Y[0bin010100101010]);
-ASSERT(X[0bin011000111001]=X[0bin010101011000]);
-ASSERT(Y[0bin011000111001]=Y[0bin010101011000]);
-ASSERT(X[0bin011000111010]=X[0bin010110000110]);
-ASSERT(Y[0bin011000111010]=Y[0bin010110000110]);
-ASSERT(X[0bin011000111011]=X[0bin010110110100]);
-ASSERT(Y[0bin011000111011]=Y[0bin010110110100]);
-ASSERT(X[0bin011000111100]=X[0bin010111100010]);
-ASSERT(Y[0bin011000111100]=Y[0bin010111100010]);
-ASSERT(X[0bin011000111101]=X[0bin011000010000]);
-ASSERT(Y[0bin011000111101]=Y[0bin011000010000]);
-ASSERT(X[0bin011000111110]=X[0bin011000111110]);
-ASSERT(Y[0bin011000111110]=Y[0bin011000111110]);
-ASSERT(X[0bin011000111111]=X[0bin011001101100]);
-ASSERT(Y[0bin011000111111]=Y[0bin011001101100]);
-ASSERT(X[0bin011001000000]=X[0bin011010011010]);
-ASSERT(Y[0bin011001000000]=Y[0bin011010011010]);
-ASSERT(X[0bin011001000001]=X[0bin011011001000]);
-ASSERT(Y[0bin011001000001]=Y[0bin011011001000]);
-ASSERT(X[0bin011001000010]=X[0bin011011110110]);
-ASSERT(Y[0bin011001000010]=Y[0bin011011110110]);
-ASSERT(X[0bin011001000011]=X[0bin011100100100]);
-ASSERT(Y[0bin011001000011]=Y[0bin011100100100]);
-ASSERT(X[0bin011001000100]=X[0bin011101010010]);
-ASSERT(Y[0bin011001000100]=Y[0bin011101010010]);
-ASSERT(X[0bin011001000101]=X[0bin011110000000]);
-ASSERT(Y[0bin011001000101]=Y[0bin011110000000]);
-ASSERT(X[0bin011001000110]=X[0bin011110101110]);
-ASSERT(Y[0bin011001000110]=Y[0bin011110101110]);
-ASSERT(X[0bin011001000111]=X[0bin011111011100]);
-ASSERT(Y[0bin011001000111]=Y[0bin011111011100]);
-ASSERT(X[0bin011001001000]=X[0bin100000001010]);
-ASSERT(Y[0bin011001001000]=Y[0bin100000001010]);
-ASSERT(X[0bin011001001001]=X[0bin100000111000]);
-ASSERT(Y[0bin011001001001]=Y[0bin100000111000]);
-ASSERT(X[0bin011001001010]=X[0bin000000100011]);
-ASSERT(Y[0bin011001001010]=Y[0bin000000100011]);
-ASSERT(X[0bin011001001011]=X[0bin000001010001]);
-ASSERT(Y[0bin011001001011]=Y[0bin000001010001]);
-ASSERT(X[0bin011001001100]=X[0bin000001111111]);
-ASSERT(Y[0bin011001001100]=Y[0bin000001111111]);
-ASSERT(X[0bin011001001101]=X[0bin000010101101]);
-ASSERT(Y[0bin011001001101]=Y[0bin000010101101]);
-ASSERT(X[0bin011001001110]=X[0bin000011011011]);
-ASSERT(Y[0bin011001001110]=Y[0bin000011011011]);
-ASSERT(X[0bin011001001111]=X[0bin000100001001]);
-ASSERT(Y[0bin011001001111]=Y[0bin000100001001]);
-ASSERT(X[0bin011001010000]=X[0bin000100110111]);
-ASSERT(Y[0bin011001010000]=Y[0bin000100110111]);
-ASSERT(X[0bin011001010001]=X[0bin000101100101]);
-ASSERT(Y[0bin011001010001]=Y[0bin000101100101]);
-ASSERT(X[0bin011001010010]=X[0bin000110010011]);
-ASSERT(Y[0bin011001010010]=Y[0bin000110010011]);
-ASSERT(X[0bin011001010011]=X[0bin000111000001]);
-ASSERT(Y[0bin011001010011]=Y[0bin000111000001]);
-ASSERT(X[0bin011001010100]=X[0bin000111101111]);
-ASSERT(Y[0bin011001010100]=Y[0bin000111101111]);
-ASSERT(X[0bin011001010101]=X[0bin001000011101]);
-ASSERT(Y[0bin011001010101]=Y[0bin001000011101]);
-ASSERT(X[0bin011001010110]=X[0bin001001001011]);
-ASSERT(Y[0bin011001010110]=Y[0bin001001001011]);
-ASSERT(X[0bin011001010111]=X[0bin001001111001]);
-ASSERT(Y[0bin011001010111]=Y[0bin001001111001]);
-ASSERT(X[0bin011001011000]=X[0bin001010100111]);
-ASSERT(Y[0bin011001011000]=Y[0bin001010100111]);
-ASSERT(X[0bin011001011001]=X[0bin001011010101]);
-ASSERT(Y[0bin011001011001]=Y[0bin001011010101]);
-ASSERT(X[0bin011001011010]=X[0bin001100000011]);
-ASSERT(Y[0bin011001011010]=Y[0bin001100000011]);
-ASSERT(X[0bin011001011011]=X[0bin001100110001]);
-ASSERT(Y[0bin011001011011]=Y[0bin001100110001]);
-ASSERT(X[0bin011001011100]=X[0bin001101011111]);
-ASSERT(Y[0bin011001011100]=Y[0bin001101011111]);
-ASSERT(X[0bin011001011101]=X[0bin001110001101]);
-ASSERT(Y[0bin011001011101]=Y[0bin001110001101]);
-ASSERT(X[0bin011001011110]=X[0bin001110111011]);
-ASSERT(Y[0bin011001011110]=Y[0bin001110111011]);
-ASSERT(X[0bin011001011111]=X[0bin001111101001]);
-ASSERT(Y[0bin011001011111]=Y[0bin001111101001]);
-ASSERT(X[0bin011001100000]=X[0bin010000010111]);
-ASSERT(Y[0bin011001100000]=Y[0bin010000010111]);
-ASSERT(X[0bin011001100001]=X[0bin010001000101]);
-ASSERT(Y[0bin011001100001]=Y[0bin010001000101]);
-ASSERT(X[0bin011001100010]=X[0bin010001110011]);
-ASSERT(Y[0bin011001100010]=Y[0bin010001110011]);
-ASSERT(X[0bin011001100011]=X[0bin010010100001]);
-ASSERT(Y[0bin011001100011]=Y[0bin010010100001]);
-ASSERT(X[0bin011001100100]=X[0bin010011001111]);
-ASSERT(Y[0bin011001100100]=Y[0bin010011001111]);
-ASSERT(X[0bin011001100101]=X[0bin010011111101]);
-ASSERT(Y[0bin011001100101]=Y[0bin010011111101]);
-ASSERT(X[0bin011001100110]=X[0bin010100101011]);
-ASSERT(Y[0bin011001100110]=Y[0bin010100101011]);
-ASSERT(X[0bin011001100111]=X[0bin010101011001]);
-ASSERT(Y[0bin011001100111]=Y[0bin010101011001]);
-ASSERT(X[0bin011001101000]=X[0bin010110000111]);
-ASSERT(Y[0bin011001101000]=Y[0bin010110000111]);
-ASSERT(X[0bin011001101001]=X[0bin010110110101]);
-ASSERT(Y[0bin011001101001]=Y[0bin010110110101]);
-ASSERT(X[0bin011001101010]=X[0bin010111100011]);
-ASSERT(Y[0bin011001101010]=Y[0bin010111100011]);
-ASSERT(X[0bin011001101011]=X[0bin011000010001]);
-ASSERT(Y[0bin011001101011]=Y[0bin011000010001]);
-ASSERT(X[0bin011001101100]=X[0bin011000111111]);
-ASSERT(Y[0bin011001101100]=Y[0bin011000111111]);
-ASSERT(X[0bin011001101101]=X[0bin011001101101]);
-ASSERT(Y[0bin011001101101]=Y[0bin011001101101]);
-ASSERT(X[0bin011001101110]=X[0bin011010011011]);
-ASSERT(Y[0bin011001101110]=Y[0bin011010011011]);
-ASSERT(X[0bin011001101111]=X[0bin011011001001]);
-ASSERT(Y[0bin011001101111]=Y[0bin011011001001]);
-ASSERT(X[0bin011001110000]=X[0bin011011110111]);
-ASSERT(Y[0bin011001110000]=Y[0bin011011110111]);
-ASSERT(X[0bin011001110001]=X[0bin011100100101]);
-ASSERT(Y[0bin011001110001]=Y[0bin011100100101]);
-ASSERT(X[0bin011001110010]=X[0bin011101010011]);
-ASSERT(Y[0bin011001110010]=Y[0bin011101010011]);
-ASSERT(X[0bin011001110011]=X[0bin011110000001]);
-ASSERT(Y[0bin011001110011]=Y[0bin011110000001]);
-ASSERT(X[0bin011001110100]=X[0bin011110101111]);
-ASSERT(Y[0bin011001110100]=Y[0bin011110101111]);
-ASSERT(X[0bin011001110101]=X[0bin011111011101]);
-ASSERT(Y[0bin011001110101]=Y[0bin011111011101]);
-ASSERT(X[0bin011001110110]=X[0bin100000001011]);
-ASSERT(Y[0bin011001110110]=Y[0bin100000001011]);
-ASSERT(X[0bin011001110111]=X[0bin100000111001]);
-ASSERT(Y[0bin011001110111]=Y[0bin100000111001]);
-ASSERT(X[0bin011001111000]=X[0bin000000100100]);
-ASSERT(Y[0bin011001111000]=Y[0bin000000100100]);
-ASSERT(X[0bin011001111001]=X[0bin000001010010]);
-ASSERT(Y[0bin011001111001]=Y[0bin000001010010]);
-ASSERT(X[0bin011001111010]=X[0bin000010000000]);
-ASSERT(Y[0bin011001111010]=Y[0bin000010000000]);
-ASSERT(X[0bin011001111011]=X[0bin000010101110]);
-ASSERT(Y[0bin011001111011]=Y[0bin000010101110]);
-ASSERT(X[0bin011001111100]=X[0bin000011011100]);
-ASSERT(Y[0bin011001111100]=Y[0bin000011011100]);
-ASSERT(X[0bin011001111101]=X[0bin000100001010]);
-ASSERT(Y[0bin011001111101]=Y[0bin000100001010]);
-ASSERT(X[0bin011001111110]=X[0bin000100111000]);
-ASSERT(Y[0bin011001111110]=Y[0bin000100111000]);
-ASSERT(X[0bin011001111111]=X[0bin000101100110]);
-ASSERT(Y[0bin011001111111]=Y[0bin000101100110]);
-ASSERT(X[0bin011010000000]=X[0bin000110010100]);
-ASSERT(Y[0bin011010000000]=Y[0bin000110010100]);
-ASSERT(X[0bin011010000001]=X[0bin000111000010]);
-ASSERT(Y[0bin011010000001]=Y[0bin000111000010]);
-ASSERT(X[0bin011010000010]=X[0bin000111110000]);
-ASSERT(Y[0bin011010000010]=Y[0bin000111110000]);
-ASSERT(X[0bin011010000011]=X[0bin001000011110]);
-ASSERT(Y[0bin011010000011]=Y[0bin001000011110]);
-ASSERT(X[0bin011010000100]=X[0bin001001001100]);
-ASSERT(Y[0bin011010000100]=Y[0bin001001001100]);
-ASSERT(X[0bin011010000101]=X[0bin001001111010]);
-ASSERT(Y[0bin011010000101]=Y[0bin001001111010]);
-ASSERT(X[0bin011010000110]=X[0bin001010101000]);
-ASSERT(Y[0bin011010000110]=Y[0bin001010101000]);
-ASSERT(X[0bin011010000111]=X[0bin001011010110]);
-ASSERT(Y[0bin011010000111]=Y[0bin001011010110]);
-ASSERT(X[0bin011010001000]=X[0bin001100000100]);
-ASSERT(Y[0bin011010001000]=Y[0bin001100000100]);
-ASSERT(X[0bin011010001001]=X[0bin001100110010]);
-ASSERT(Y[0bin011010001001]=Y[0bin001100110010]);
-ASSERT(X[0bin011010001010]=X[0bin001101100000]);
-ASSERT(Y[0bin011010001010]=Y[0bin001101100000]);
-ASSERT(X[0bin011010001011]=X[0bin001110001110]);
-ASSERT(Y[0bin011010001011]=Y[0bin001110001110]);
-ASSERT(X[0bin011010001100]=X[0bin001110111100]);
-ASSERT(Y[0bin011010001100]=Y[0bin001110111100]);
-ASSERT(X[0bin011010001101]=X[0bin001111101010]);
-ASSERT(Y[0bin011010001101]=Y[0bin001111101010]);
-ASSERT(X[0bin011010001110]=X[0bin010000011000]);
-ASSERT(Y[0bin011010001110]=Y[0bin010000011000]);
-ASSERT(X[0bin011010001111]=X[0bin010001000110]);
-ASSERT(Y[0bin011010001111]=Y[0bin010001000110]);
-ASSERT(X[0bin011010010000]=X[0bin010001110100]);
-ASSERT(Y[0bin011010010000]=Y[0bin010001110100]);
-ASSERT(X[0bin011010010001]=X[0bin010010100010]);
-ASSERT(Y[0bin011010010001]=Y[0bin010010100010]);
-ASSERT(X[0bin011010010010]=X[0bin010011010000]);
-ASSERT(Y[0bin011010010010]=Y[0bin010011010000]);
-ASSERT(X[0bin011010010011]=X[0bin010011111110]);
-ASSERT(Y[0bin011010010011]=Y[0bin010011111110]);
-ASSERT(X[0bin011010010100]=X[0bin010100101100]);
-ASSERT(Y[0bin011010010100]=Y[0bin010100101100]);
-ASSERT(X[0bin011010010101]=X[0bin010101011010]);
-ASSERT(Y[0bin011010010101]=Y[0bin010101011010]);
-ASSERT(X[0bin011010010110]=X[0bin010110001000]);
-ASSERT(Y[0bin011010010110]=Y[0bin010110001000]);
-ASSERT(X[0bin011010010111]=X[0bin010110110110]);
-ASSERT(Y[0bin011010010111]=Y[0bin010110110110]);
-ASSERT(X[0bin011010011000]=X[0bin010111100100]);
-ASSERT(Y[0bin011010011000]=Y[0bin010111100100]);
-ASSERT(X[0bin011010011001]=X[0bin011000010010]);
-ASSERT(Y[0bin011010011001]=Y[0bin011000010010]);
-ASSERT(X[0bin011010011010]=X[0bin011001000000]);
-ASSERT(Y[0bin011010011010]=Y[0bin011001000000]);
-ASSERT(X[0bin011010011011]=X[0bin011001101110]);
-ASSERT(Y[0bin011010011011]=Y[0bin011001101110]);
-ASSERT(X[0bin011010011100]=X[0bin011010011100]);
-ASSERT(Y[0bin011010011100]=Y[0bin011010011100]);
-ASSERT(X[0bin011010011101]=X[0bin011011001010]);
-ASSERT(Y[0bin011010011101]=Y[0bin011011001010]);
-ASSERT(X[0bin011010011110]=X[0bin011011111000]);
-ASSERT(Y[0bin011010011110]=Y[0bin011011111000]);
-ASSERT(X[0bin011010011111]=X[0bin011100100110]);
-ASSERT(Y[0bin011010011111]=Y[0bin011100100110]);
-ASSERT(X[0bin011010100000]=X[0bin011101010100]);
-ASSERT(Y[0bin011010100000]=Y[0bin011101010100]);
-ASSERT(X[0bin011010100001]=X[0bin011110000010]);
-ASSERT(Y[0bin011010100001]=Y[0bin011110000010]);
-ASSERT(X[0bin011010100010]=X[0bin011110110000]);
-ASSERT(Y[0bin011010100010]=Y[0bin011110110000]);
-ASSERT(X[0bin011010100011]=X[0bin011111011110]);
-ASSERT(Y[0bin011010100011]=Y[0bin011111011110]);
-ASSERT(X[0bin011010100100]=X[0bin100000001100]);
-ASSERT(Y[0bin011010100100]=Y[0bin100000001100]);
-ASSERT(X[0bin011010100101]=X[0bin100000111010]);
-ASSERT(Y[0bin011010100101]=Y[0bin100000111010]);
-ASSERT(X[0bin011010100110]=X[0bin000000100101]);
-ASSERT(Y[0bin011010100110]=Y[0bin000000100101]);
-ASSERT(X[0bin011010100111]=X[0bin000001010011]);
-ASSERT(Y[0bin011010100111]=Y[0bin000001010011]);
-ASSERT(X[0bin011010101000]=X[0bin000010000001]);
-ASSERT(Y[0bin011010101000]=Y[0bin000010000001]);
-ASSERT(X[0bin011010101001]=X[0bin000010101111]);
-ASSERT(Y[0bin011010101001]=Y[0bin000010101111]);
-ASSERT(X[0bin011010101010]=X[0bin000011011101]);
-ASSERT(Y[0bin011010101010]=Y[0bin000011011101]);
-ASSERT(X[0bin011010101011]=X[0bin000100001011]);
-ASSERT(Y[0bin011010101011]=Y[0bin000100001011]);
-ASSERT(X[0bin011010101100]=X[0bin000100111001]);
-ASSERT(Y[0bin011010101100]=Y[0bin000100111001]);
-ASSERT(X[0bin011010101101]=X[0bin000101100111]);
-ASSERT(Y[0bin011010101101]=Y[0bin000101100111]);
-ASSERT(X[0bin011010101110]=X[0bin000110010101]);
-ASSERT(Y[0bin011010101110]=Y[0bin000110010101]);
-ASSERT(X[0bin011010101111]=X[0bin000111000011]);
-ASSERT(Y[0bin011010101111]=Y[0bin000111000011]);
-ASSERT(X[0bin011010110000]=X[0bin000111110001]);
-ASSERT(Y[0bin011010110000]=Y[0bin000111110001]);
-ASSERT(X[0bin011010110001]=X[0bin001000011111]);
-ASSERT(Y[0bin011010110001]=Y[0bin001000011111]);
-ASSERT(X[0bin011010110010]=X[0bin001001001101]);
-ASSERT(Y[0bin011010110010]=Y[0bin001001001101]);
-ASSERT(X[0bin011010110011]=X[0bin001001111011]);
-ASSERT(Y[0bin011010110011]=Y[0bin001001111011]);
-ASSERT(X[0bin011010110100]=X[0bin001010101001]);
-ASSERT(Y[0bin011010110100]=Y[0bin001010101001]);
-ASSERT(X[0bin011010110101]=X[0bin001011010111]);
-ASSERT(Y[0bin011010110101]=Y[0bin001011010111]);
-ASSERT(X[0bin011010110110]=X[0bin001100000101]);
-ASSERT(Y[0bin011010110110]=Y[0bin001100000101]);
-ASSERT(X[0bin011010110111]=X[0bin001100110011]);
-ASSERT(Y[0bin011010110111]=Y[0bin001100110011]);
-ASSERT(X[0bin011010111000]=X[0bin001101100001]);
-ASSERT(Y[0bin011010111000]=Y[0bin001101100001]);
-ASSERT(X[0bin011010111001]=X[0bin001110001111]);
-ASSERT(Y[0bin011010111001]=Y[0bin001110001111]);
-ASSERT(X[0bin011010111010]=X[0bin001110111101]);
-ASSERT(Y[0bin011010111010]=Y[0bin001110111101]);
-ASSERT(X[0bin011010111011]=X[0bin001111101011]);
-ASSERT(Y[0bin011010111011]=Y[0bin001111101011]);
-ASSERT(X[0bin011010111100]=X[0bin010000011001]);
-ASSERT(Y[0bin011010111100]=Y[0bin010000011001]);
-ASSERT(X[0bin011010111101]=X[0bin010001000111]);
-ASSERT(Y[0bin011010111101]=Y[0bin010001000111]);
-ASSERT(X[0bin011010111110]=X[0bin010001110101]);
-ASSERT(Y[0bin011010111110]=Y[0bin010001110101]);
-ASSERT(X[0bin011010111111]=X[0bin010010100011]);
-ASSERT(Y[0bin011010111111]=Y[0bin010010100011]);
-ASSERT(X[0bin011011000000]=X[0bin010011010001]);
-ASSERT(Y[0bin011011000000]=Y[0bin010011010001]);
-ASSERT(X[0bin011011000001]=X[0bin010011111111]);
-ASSERT(Y[0bin011011000001]=Y[0bin010011111111]);
-ASSERT(X[0bin011011000010]=X[0bin010100101101]);
-ASSERT(Y[0bin011011000010]=Y[0bin010100101101]);
-ASSERT(X[0bin011011000011]=X[0bin010101011011]);
-ASSERT(Y[0bin011011000011]=Y[0bin010101011011]);
-ASSERT(X[0bin011011000100]=X[0bin010110001001]);
-ASSERT(Y[0bin011011000100]=Y[0bin010110001001]);
-ASSERT(X[0bin011011000101]=X[0bin010110110111]);
-ASSERT(Y[0bin011011000101]=Y[0bin010110110111]);
-ASSERT(X[0bin011011000110]=X[0bin010111100101]);
-ASSERT(Y[0bin011011000110]=Y[0bin010111100101]);
-ASSERT(X[0bin011011000111]=X[0bin011000010011]);
-ASSERT(Y[0bin011011000111]=Y[0bin011000010011]);
-ASSERT(X[0bin011011001000]=X[0bin011001000001]);
-ASSERT(Y[0bin011011001000]=Y[0bin011001000001]);
-ASSERT(X[0bin011011001001]=X[0bin011001101111]);
-ASSERT(Y[0bin011011001001]=Y[0bin011001101111]);
-ASSERT(X[0bin011011001010]=X[0bin011010011101]);
-ASSERT(Y[0bin011011001010]=Y[0bin011010011101]);
-ASSERT(X[0bin011011001011]=X[0bin011011001011]);
-ASSERT(Y[0bin011011001011]=Y[0bin011011001011]);
-ASSERT(X[0bin011011001100]=X[0bin011011111001]);
-ASSERT(Y[0bin011011001100]=Y[0bin011011111001]);
-ASSERT(X[0bin011011001101]=X[0bin011100100111]);
-ASSERT(Y[0bin011011001101]=Y[0bin011100100111]);
-ASSERT(X[0bin011011001110]=X[0bin011101010101]);
-ASSERT(Y[0bin011011001110]=Y[0bin011101010101]);
-ASSERT(X[0bin011011001111]=X[0bin011110000011]);
-ASSERT(Y[0bin011011001111]=Y[0bin011110000011]);
-ASSERT(X[0bin011011010000]=X[0bin011110110001]);
-ASSERT(Y[0bin011011010000]=Y[0bin011110110001]);
-ASSERT(X[0bin011011010001]=X[0bin011111011111]);
-ASSERT(Y[0bin011011010001]=Y[0bin011111011111]);
-ASSERT(X[0bin011011010010]=X[0bin100000001101]);
-ASSERT(Y[0bin011011010010]=Y[0bin100000001101]);
-ASSERT(X[0bin011011010011]=X[0bin100000111011]);
-ASSERT(Y[0bin011011010011]=Y[0bin100000111011]);
-ASSERT(X[0bin011011010100]=X[0bin000000100110]);
-ASSERT(Y[0bin011011010100]=Y[0bin000000100110]);
-ASSERT(X[0bin011011010101]=X[0bin000001010100]);
-ASSERT(Y[0bin011011010101]=Y[0bin000001010100]);
-ASSERT(X[0bin011011010110]=X[0bin000010000010]);
-ASSERT(Y[0bin011011010110]=Y[0bin000010000010]);
-ASSERT(X[0bin011011010111]=X[0bin000010110000]);
-ASSERT(Y[0bin011011010111]=Y[0bin000010110000]);
-ASSERT(X[0bin011011011000]=X[0bin000011011110]);
-ASSERT(Y[0bin011011011000]=Y[0bin000011011110]);
-ASSERT(X[0bin011011011001]=X[0bin000100001100]);
-ASSERT(Y[0bin011011011001]=Y[0bin000100001100]);
-ASSERT(X[0bin011011011010]=X[0bin000100111010]);
-ASSERT(Y[0bin011011011010]=Y[0bin000100111010]);
-ASSERT(X[0bin011011011011]=X[0bin000101101000]);
-ASSERT(Y[0bin011011011011]=Y[0bin000101101000]);
-ASSERT(X[0bin011011011100]=X[0bin000110010110]);
-ASSERT(Y[0bin011011011100]=Y[0bin000110010110]);
-ASSERT(X[0bin011011011101]=X[0bin000111000100]);
-ASSERT(Y[0bin011011011101]=Y[0bin000111000100]);
-ASSERT(X[0bin011011011110]=X[0bin000111110010]);
-ASSERT(Y[0bin011011011110]=Y[0bin000111110010]);
-ASSERT(X[0bin011011011111]=X[0bin001000100000]);
-ASSERT(Y[0bin011011011111]=Y[0bin001000100000]);
-ASSERT(X[0bin011011100000]=X[0bin001001001110]);
-ASSERT(Y[0bin011011100000]=Y[0bin001001001110]);
-ASSERT(X[0bin011011100001]=X[0bin001001111100]);
-ASSERT(Y[0bin011011100001]=Y[0bin001001111100]);
-ASSERT(X[0bin011011100010]=X[0bin001010101010]);
-ASSERT(Y[0bin011011100010]=Y[0bin001010101010]);
-ASSERT(X[0bin011011100011]=X[0bin001011011000]);
-ASSERT(Y[0bin011011100011]=Y[0bin001011011000]);
-ASSERT(X[0bin011011100100]=X[0bin001100000110]);
-ASSERT(Y[0bin011011100100]=Y[0bin001100000110]);
-ASSERT(X[0bin011011100101]=X[0bin001100110100]);
-ASSERT(Y[0bin011011100101]=Y[0bin001100110100]);
-ASSERT(X[0bin011011100110]=X[0bin001101100010]);
-ASSERT(Y[0bin011011100110]=Y[0bin001101100010]);
-ASSERT(X[0bin011011100111]=X[0bin001110010000]);
-ASSERT(Y[0bin011011100111]=Y[0bin001110010000]);
-ASSERT(X[0bin011011101000]=X[0bin001110111110]);
-ASSERT(Y[0bin011011101000]=Y[0bin001110111110]);
-ASSERT(X[0bin011011101001]=X[0bin001111101100]);
-ASSERT(Y[0bin011011101001]=Y[0bin001111101100]);
-ASSERT(X[0bin011011101010]=X[0bin010000011010]);
-ASSERT(Y[0bin011011101010]=Y[0bin010000011010]);
-ASSERT(X[0bin011011101011]=X[0bin010001001000]);
-ASSERT(Y[0bin011011101011]=Y[0bin010001001000]);
-ASSERT(X[0bin011011101100]=X[0bin010001110110]);
-ASSERT(Y[0bin011011101100]=Y[0bin010001110110]);
-ASSERT(X[0bin011011101101]=X[0bin010010100100]);
-ASSERT(Y[0bin011011101101]=Y[0bin010010100100]);
-ASSERT(X[0bin011011101110]=X[0bin010011010010]);
-ASSERT(Y[0bin011011101110]=Y[0bin010011010010]);
-ASSERT(X[0bin011011101111]=X[0bin010100000000]);
-ASSERT(Y[0bin011011101111]=Y[0bin010100000000]);
-ASSERT(X[0bin011011110000]=X[0bin010100101110]);
-ASSERT(Y[0bin011011110000]=Y[0bin010100101110]);
-ASSERT(X[0bin011011110001]=X[0bin010101011100]);
-ASSERT(Y[0bin011011110001]=Y[0bin010101011100]);
-ASSERT(X[0bin011011110010]=X[0bin010110001010]);
-ASSERT(Y[0bin011011110010]=Y[0bin010110001010]);
-ASSERT(X[0bin011011110011]=X[0bin010110111000]);
-ASSERT(Y[0bin011011110011]=Y[0bin010110111000]);
-ASSERT(X[0bin011011110100]=X[0bin010111100110]);
-ASSERT(Y[0bin011011110100]=Y[0bin010111100110]);
-ASSERT(X[0bin011011110101]=X[0bin011000010100]);
-ASSERT(Y[0bin011011110101]=Y[0bin011000010100]);
-ASSERT(X[0bin011011110110]=X[0bin011001000010]);
-ASSERT(Y[0bin011011110110]=Y[0bin011001000010]);
-ASSERT(X[0bin011011110111]=X[0bin011001110000]);
-ASSERT(Y[0bin011011110111]=Y[0bin011001110000]);
-ASSERT(X[0bin011011111000]=X[0bin011010011110]);
-ASSERT(Y[0bin011011111000]=Y[0bin011010011110]);
-ASSERT(X[0bin011011111001]=X[0bin011011001100]);
-ASSERT(Y[0bin011011111001]=Y[0bin011011001100]);
-ASSERT(X[0bin011011111010]=X[0bin011011111010]);
-ASSERT(Y[0bin011011111010]=Y[0bin011011111010]);
-ASSERT(X[0bin011011111011]=X[0bin011100101000]);
-ASSERT(Y[0bin011011111011]=Y[0bin011100101000]);
-ASSERT(X[0bin011011111100]=X[0bin011101010110]);
-ASSERT(Y[0bin011011111100]=Y[0bin011101010110]);
-ASSERT(X[0bin011011111101]=X[0bin011110000100]);
-ASSERT(Y[0bin011011111101]=Y[0bin011110000100]);
-ASSERT(X[0bin011011111110]=X[0bin011110110010]);
-ASSERT(Y[0bin011011111110]=Y[0bin011110110010]);
-ASSERT(X[0bin011011111111]=X[0bin011111100000]);
-ASSERT(Y[0bin011011111111]=Y[0bin011111100000]);
-ASSERT(X[0bin011100000000]=X[0bin100000001110]);
-ASSERT(Y[0bin011100000000]=Y[0bin100000001110]);
-ASSERT(X[0bin011100000001]=X[0bin100000111100]);
-ASSERT(Y[0bin011100000001]=Y[0bin100000111100]);
-ASSERT(X[0bin011100000010]=X[0bin000000100111]);
-ASSERT(Y[0bin011100000010]=Y[0bin000000100111]);
-ASSERT(X[0bin011100000011]=X[0bin000001010101]);
-ASSERT(Y[0bin011100000011]=Y[0bin000001010101]);
-ASSERT(X[0bin011100000100]=X[0bin000010000011]);
-ASSERT(Y[0bin011100000100]=Y[0bin000010000011]);
-ASSERT(X[0bin011100000101]=X[0bin000010110001]);
-ASSERT(Y[0bin011100000101]=Y[0bin000010110001]);
-ASSERT(X[0bin011100000110]=X[0bin000011011111]);
-ASSERT(Y[0bin011100000110]=Y[0bin000011011111]);
-ASSERT(X[0bin011100000111]=X[0bin000100001101]);
-ASSERT(Y[0bin011100000111]=Y[0bin000100001101]);
-ASSERT(X[0bin011100001000]=X[0bin000100111011]);
-ASSERT(Y[0bin011100001000]=Y[0bin000100111011]);
-ASSERT(X[0bin011100001001]=X[0bin000101101001]);
-ASSERT(Y[0bin011100001001]=Y[0bin000101101001]);
-ASSERT(X[0bin011100001010]=X[0bin000110010111]);
-ASSERT(Y[0bin011100001010]=Y[0bin000110010111]);
-ASSERT(X[0bin011100001011]=X[0bin000111000101]);
-ASSERT(Y[0bin011100001011]=Y[0bin000111000101]);
-ASSERT(X[0bin011100001100]=X[0bin000111110011]);
-ASSERT(Y[0bin011100001100]=Y[0bin000111110011]);
-ASSERT(X[0bin011100001101]=X[0bin001000100001]);
-ASSERT(Y[0bin011100001101]=Y[0bin001000100001]);
-ASSERT(X[0bin011100001110]=X[0bin001001001111]);
-ASSERT(Y[0bin011100001110]=Y[0bin001001001111]);
-ASSERT(X[0bin011100001111]=X[0bin001001111101]);
-ASSERT(Y[0bin011100001111]=Y[0bin001001111101]);
-ASSERT(X[0bin011100010000]=X[0bin001010101011]);
-ASSERT(Y[0bin011100010000]=Y[0bin001010101011]);
-ASSERT(X[0bin011100010001]=X[0bin001011011001]);
-ASSERT(Y[0bin011100010001]=Y[0bin001011011001]);
-ASSERT(X[0bin011100010010]=X[0bin001100000111]);
-ASSERT(Y[0bin011100010010]=Y[0bin001100000111]);
-ASSERT(X[0bin011100010011]=X[0bin001100110101]);
-ASSERT(Y[0bin011100010011]=Y[0bin001100110101]);
-ASSERT(X[0bin011100010100]=X[0bin001101100011]);
-ASSERT(Y[0bin011100010100]=Y[0bin001101100011]);
-ASSERT(X[0bin011100010101]=X[0bin001110010001]);
-ASSERT(Y[0bin011100010101]=Y[0bin001110010001]);
-ASSERT(X[0bin011100010110]=X[0bin001110111111]);
-ASSERT(Y[0bin011100010110]=Y[0bin001110111111]);
-ASSERT(X[0bin011100010111]=X[0bin001111101101]);
-ASSERT(Y[0bin011100010111]=Y[0bin001111101101]);
-ASSERT(X[0bin011100011000]=X[0bin010000011011]);
-ASSERT(Y[0bin011100011000]=Y[0bin010000011011]);
-ASSERT(X[0bin011100011001]=X[0bin010001001001]);
-ASSERT(Y[0bin011100011001]=Y[0bin010001001001]);
-ASSERT(X[0bin011100011010]=X[0bin010001110111]);
-ASSERT(Y[0bin011100011010]=Y[0bin010001110111]);
-ASSERT(X[0bin011100011011]=X[0bin010010100101]);
-ASSERT(Y[0bin011100011011]=Y[0bin010010100101]);
-ASSERT(X[0bin011100011100]=X[0bin010011010011]);
-ASSERT(Y[0bin011100011100]=Y[0bin010011010011]);
-ASSERT(X[0bin011100011101]=X[0bin010100000001]);
-ASSERT(Y[0bin011100011101]=Y[0bin010100000001]);
-ASSERT(X[0bin011100011110]=X[0bin010100101111]);
-ASSERT(Y[0bin011100011110]=Y[0bin010100101111]);
-ASSERT(X[0bin011100011111]=X[0bin010101011101]);
-ASSERT(Y[0bin011100011111]=Y[0bin010101011101]);
-ASSERT(X[0bin011100100000]=X[0bin010110001011]);
-ASSERT(Y[0bin011100100000]=Y[0bin010110001011]);
-ASSERT(X[0bin011100100001]=X[0bin010110111001]);
-ASSERT(Y[0bin011100100001]=Y[0bin010110111001]);
-ASSERT(X[0bin011100100010]=X[0bin010111100111]);
-ASSERT(Y[0bin011100100010]=Y[0bin010111100111]);
-ASSERT(X[0bin011100100011]=X[0bin011000010101]);
-ASSERT(Y[0bin011100100011]=Y[0bin011000010101]);
-ASSERT(X[0bin011100100100]=X[0bin011001000011]);
-ASSERT(Y[0bin011100100100]=Y[0bin011001000011]);
-ASSERT(X[0bin011100100101]=X[0bin011001110001]);
-ASSERT(Y[0bin011100100101]=Y[0bin011001110001]);
-ASSERT(X[0bin011100100110]=X[0bin011010011111]);
-ASSERT(Y[0bin011100100110]=Y[0bin011010011111]);
-ASSERT(X[0bin011100100111]=X[0bin011011001101]);
-ASSERT(Y[0bin011100100111]=Y[0bin011011001101]);
-ASSERT(X[0bin011100101000]=X[0bin011011111011]);
-ASSERT(Y[0bin011100101000]=Y[0bin011011111011]);
-ASSERT(X[0bin011100101001]=X[0bin011100101001]);
-ASSERT(Y[0bin011100101001]=Y[0bin011100101001]);
-ASSERT(X[0bin011100101010]=X[0bin011101010111]);
-ASSERT(Y[0bin011100101010]=Y[0bin011101010111]);
-ASSERT(X[0bin011100101011]=X[0bin011110000101]);
-ASSERT(Y[0bin011100101011]=Y[0bin011110000101]);
-ASSERT(X[0bin011100101100]=X[0bin011110110011]);
-ASSERT(Y[0bin011100101100]=Y[0bin011110110011]);
-ASSERT(X[0bin011100101101]=X[0bin011111100001]);
-ASSERT(Y[0bin011100101101]=Y[0bin011111100001]);
-ASSERT(X[0bin011100101110]=X[0bin100000001111]);
-ASSERT(Y[0bin011100101110]=Y[0bin100000001111]);
-ASSERT(X[0bin011100101111]=X[0bin100000111101]);
-ASSERT(Y[0bin011100101111]=Y[0bin100000111101]);
-ASSERT(X[0bin011100110000]=X[0bin000000101000]);
-ASSERT(Y[0bin011100110000]=Y[0bin000000101000]);
-ASSERT(X[0bin011100110001]=X[0bin000001010110]);
-ASSERT(Y[0bin011100110001]=Y[0bin000001010110]);
-ASSERT(X[0bin011100110010]=X[0bin000010000100]);
-ASSERT(Y[0bin011100110010]=Y[0bin000010000100]);
-ASSERT(X[0bin011100110011]=X[0bin000010110010]);
-ASSERT(Y[0bin011100110011]=Y[0bin000010110010]);
-ASSERT(X[0bin011100110100]=X[0bin000011100000]);
-ASSERT(Y[0bin011100110100]=Y[0bin000011100000]);
-ASSERT(X[0bin011100110101]=X[0bin000100001110]);
-ASSERT(Y[0bin011100110101]=Y[0bin000100001110]);
-ASSERT(X[0bin011100110110]=X[0bin000100111100]);
-ASSERT(Y[0bin011100110110]=Y[0bin000100111100]);
-ASSERT(X[0bin011100110111]=X[0bin000101101010]);
-ASSERT(Y[0bin011100110111]=Y[0bin000101101010]);
-ASSERT(X[0bin011100111000]=X[0bin000110011000]);
-ASSERT(Y[0bin011100111000]=Y[0bin000110011000]);
-ASSERT(X[0bin011100111001]=X[0bin000111000110]);
-ASSERT(Y[0bin011100111001]=Y[0bin000111000110]);
-ASSERT(X[0bin011100111010]=X[0bin000111110100]);
-ASSERT(Y[0bin011100111010]=Y[0bin000111110100]);
-ASSERT(X[0bin011100111011]=X[0bin001000100010]);
-ASSERT(Y[0bin011100111011]=Y[0bin001000100010]);
-ASSERT(X[0bin011100111100]=X[0bin001001010000]);
-ASSERT(Y[0bin011100111100]=Y[0bin001001010000]);
-ASSERT(X[0bin011100111101]=X[0bin001001111110]);
-ASSERT(Y[0bin011100111101]=Y[0bin001001111110]);
-ASSERT(X[0bin011100111110]=X[0bin001010101100]);
-ASSERT(Y[0bin011100111110]=Y[0bin001010101100]);
-ASSERT(X[0bin011100111111]=X[0bin001011011010]);
-ASSERT(Y[0bin011100111111]=Y[0bin001011011010]);
-ASSERT(X[0bin011101000000]=X[0bin001100001000]);
-ASSERT(Y[0bin011101000000]=Y[0bin001100001000]);
-ASSERT(X[0bin011101000001]=X[0bin001100110110]);
-ASSERT(Y[0bin011101000001]=Y[0bin001100110110]);
-ASSERT(X[0bin011101000010]=X[0bin001101100100]);
-ASSERT(Y[0bin011101000010]=Y[0bin001101100100]);
-ASSERT(X[0bin011101000011]=X[0bin001110010010]);
-ASSERT(Y[0bin011101000011]=Y[0bin001110010010]);
-ASSERT(X[0bin011101000100]=X[0bin001111000000]);
-ASSERT(Y[0bin011101000100]=Y[0bin001111000000]);
-ASSERT(X[0bin011101000101]=X[0bin001111101110]);
-ASSERT(Y[0bin011101000101]=Y[0bin001111101110]);
-ASSERT(X[0bin011101000110]=X[0bin010000011100]);
-ASSERT(Y[0bin011101000110]=Y[0bin010000011100]);
-ASSERT(X[0bin011101000111]=X[0bin010001001010]);
-ASSERT(Y[0bin011101000111]=Y[0bin010001001010]);
-ASSERT(X[0bin011101001000]=X[0bin010001111000]);
-ASSERT(Y[0bin011101001000]=Y[0bin010001111000]);
-ASSERT(X[0bin011101001001]=X[0bin010010100110]);
-ASSERT(Y[0bin011101001001]=Y[0bin010010100110]);
-ASSERT(X[0bin011101001010]=X[0bin010011010100]);
-ASSERT(Y[0bin011101001010]=Y[0bin010011010100]);
-ASSERT(X[0bin011101001011]=X[0bin010100000010]);
-ASSERT(Y[0bin011101001011]=Y[0bin010100000010]);
-ASSERT(X[0bin011101001100]=X[0bin010100110000]);
-ASSERT(Y[0bin011101001100]=Y[0bin010100110000]);
-ASSERT(X[0bin011101001101]=X[0bin010101011110]);
-ASSERT(Y[0bin011101001101]=Y[0bin010101011110]);
-ASSERT(X[0bin011101001110]=X[0bin010110001100]);
-ASSERT(Y[0bin011101001110]=Y[0bin010110001100]);
-ASSERT(X[0bin011101001111]=X[0bin010110111010]);
-ASSERT(Y[0bin011101001111]=Y[0bin010110111010]);
-ASSERT(X[0bin011101010000]=X[0bin010111101000]);
-ASSERT(Y[0bin011101010000]=Y[0bin010111101000]);
-ASSERT(X[0bin011101010001]=X[0bin011000010110]);
-ASSERT(Y[0bin011101010001]=Y[0bin011000010110]);
-ASSERT(X[0bin011101010010]=X[0bin011001000100]);
-ASSERT(Y[0bin011101010010]=Y[0bin011001000100]);
-ASSERT(X[0bin011101010011]=X[0bin011001110010]);
-ASSERT(Y[0bin011101010011]=Y[0bin011001110010]);
-ASSERT(X[0bin011101010100]=X[0bin011010100000]);
-ASSERT(Y[0bin011101010100]=Y[0bin011010100000]);
-ASSERT(X[0bin011101010101]=X[0bin011011001110]);
-ASSERT(Y[0bin011101010101]=Y[0bin011011001110]);
-ASSERT(X[0bin011101010110]=X[0bin011011111100]);
-ASSERT(Y[0bin011101010110]=Y[0bin011011111100]);
-ASSERT(X[0bin011101010111]=X[0bin011100101010]);
-ASSERT(Y[0bin011101010111]=Y[0bin011100101010]);
-ASSERT(X[0bin011101011000]=X[0bin011101011000]);
-ASSERT(Y[0bin011101011000]=Y[0bin011101011000]);
-ASSERT(X[0bin011101011001]=X[0bin011110000110]);
-ASSERT(Y[0bin011101011001]=Y[0bin011110000110]);
-ASSERT(X[0bin011101011010]=X[0bin011110110100]);
-ASSERT(Y[0bin011101011010]=Y[0bin011110110100]);
-ASSERT(X[0bin011101011011]=X[0bin011111100010]);
-ASSERT(Y[0bin011101011011]=Y[0bin011111100010]);
-ASSERT(X[0bin011101011100]=X[0bin100000010000]);
-ASSERT(Y[0bin011101011100]=Y[0bin100000010000]);
-ASSERT(X[0bin011101011101]=X[0bin100000111110]);
-ASSERT(Y[0bin011101011101]=Y[0bin100000111110]);
-ASSERT(X[0bin011101011110]=X[0bin000000101001]);
-ASSERT(Y[0bin011101011110]=Y[0bin000000101001]);
-ASSERT(X[0bin011101011111]=X[0bin000001010111]);
-ASSERT(Y[0bin011101011111]=Y[0bin000001010111]);
-ASSERT(X[0bin011101100000]=X[0bin000010000101]);
-ASSERT(Y[0bin011101100000]=Y[0bin000010000101]);
-ASSERT(X[0bin011101100001]=X[0bin000010110011]);
-ASSERT(Y[0bin011101100001]=Y[0bin000010110011]);
-ASSERT(X[0bin011101100010]=X[0bin000011100001]);
-ASSERT(Y[0bin011101100010]=Y[0bin000011100001]);
-ASSERT(X[0bin011101100011]=X[0bin000100001111]);
-ASSERT(Y[0bin011101100011]=Y[0bin000100001111]);
-ASSERT(X[0bin011101100100]=X[0bin000100111101]);
-ASSERT(Y[0bin011101100100]=Y[0bin000100111101]);
-ASSERT(X[0bin011101100101]=X[0bin000101101011]);
-ASSERT(Y[0bin011101100101]=Y[0bin000101101011]);
-ASSERT(X[0bin011101100110]=X[0bin000110011001]);
-ASSERT(Y[0bin011101100110]=Y[0bin000110011001]);
-ASSERT(X[0bin011101100111]=X[0bin000111000111]);
-ASSERT(Y[0bin011101100111]=Y[0bin000111000111]);
-ASSERT(X[0bin011101101000]=X[0bin000111110101]);
-ASSERT(Y[0bin011101101000]=Y[0bin000111110101]);
-ASSERT(X[0bin011101101001]=X[0bin001000100011]);
-ASSERT(Y[0bin011101101001]=Y[0bin001000100011]);
-ASSERT(X[0bin011101101010]=X[0bin001001010001]);
-ASSERT(Y[0bin011101101010]=Y[0bin001001010001]);
-ASSERT(X[0bin011101101011]=X[0bin001001111111]);
-ASSERT(Y[0bin011101101011]=Y[0bin001001111111]);
-ASSERT(X[0bin011101101100]=X[0bin001010101101]);
-ASSERT(Y[0bin011101101100]=Y[0bin001010101101]);
-ASSERT(X[0bin011101101101]=X[0bin001011011011]);
-ASSERT(Y[0bin011101101101]=Y[0bin001011011011]);
-ASSERT(X[0bin011101101110]=X[0bin001100001001]);
-ASSERT(Y[0bin011101101110]=Y[0bin001100001001]);
-ASSERT(X[0bin011101101111]=X[0bin001100110111]);
-ASSERT(Y[0bin011101101111]=Y[0bin001100110111]);
-ASSERT(X[0bin011101110000]=X[0bin001101100101]);
-ASSERT(Y[0bin011101110000]=Y[0bin001101100101]);
-ASSERT(X[0bin011101110001]=X[0bin001110010011]);
-ASSERT(Y[0bin011101110001]=Y[0bin001110010011]);
-ASSERT(X[0bin011101110010]=X[0bin001111000001]);
-ASSERT(Y[0bin011101110010]=Y[0bin001111000001]);
-ASSERT(X[0bin011101110011]=X[0bin001111101111]);
-ASSERT(Y[0bin011101110011]=Y[0bin001111101111]);
-ASSERT(X[0bin011101110100]=X[0bin010000011101]);
-ASSERT(Y[0bin011101110100]=Y[0bin010000011101]);
-ASSERT(X[0bin011101110101]=X[0bin010001001011]);
-ASSERT(Y[0bin011101110101]=Y[0bin010001001011]);
-ASSERT(X[0bin011101110110]=X[0bin010001111001]);
-ASSERT(Y[0bin011101110110]=Y[0bin010001111001]);
-ASSERT(X[0bin011101110111]=X[0bin010010100111]);
-ASSERT(Y[0bin011101110111]=Y[0bin010010100111]);
-ASSERT(X[0bin011101111000]=X[0bin010011010101]);
-ASSERT(Y[0bin011101111000]=Y[0bin010011010101]);
-ASSERT(X[0bin011101111001]=X[0bin010100000011]);
-ASSERT(Y[0bin011101111001]=Y[0bin010100000011]);
-ASSERT(X[0bin011101111010]=X[0bin010100110001]);
-ASSERT(Y[0bin011101111010]=Y[0bin010100110001]);
-ASSERT(X[0bin011101111011]=X[0bin010101011111]);
-ASSERT(Y[0bin011101111011]=Y[0bin010101011111]);
-ASSERT(X[0bin011101111100]=X[0bin010110001101]);
-ASSERT(Y[0bin011101111100]=Y[0bin010110001101]);
-ASSERT(X[0bin011101111101]=X[0bin010110111011]);
-ASSERT(Y[0bin011101111101]=Y[0bin010110111011]);
-ASSERT(X[0bin011101111110]=X[0bin010111101001]);
-ASSERT(Y[0bin011101111110]=Y[0bin010111101001]);
-ASSERT(X[0bin011101111111]=X[0bin011000010111]);
-ASSERT(Y[0bin011101111111]=Y[0bin011000010111]);
-ASSERT(X[0bin011110000000]=X[0bin011001000101]);
-ASSERT(Y[0bin011110000000]=Y[0bin011001000101]);
-ASSERT(X[0bin011110000001]=X[0bin011001110011]);
-ASSERT(Y[0bin011110000001]=Y[0bin011001110011]);
-ASSERT(X[0bin011110000010]=X[0bin011010100001]);
-ASSERT(Y[0bin011110000010]=Y[0bin011010100001]);
-ASSERT(X[0bin011110000011]=X[0bin011011001111]);
-ASSERT(Y[0bin011110000011]=Y[0bin011011001111]);
-ASSERT(X[0bin011110000100]=X[0bin011011111101]);
-ASSERT(Y[0bin011110000100]=Y[0bin011011111101]);
-ASSERT(X[0bin011110000101]=X[0bin011100101011]);
-ASSERT(Y[0bin011110000101]=Y[0bin011100101011]);
-ASSERT(X[0bin011110000110]=X[0bin011101011001]);
-ASSERT(Y[0bin011110000110]=Y[0bin011101011001]);
-ASSERT(X[0bin011110000111]=X[0bin011110000111]);
-ASSERT(Y[0bin011110000111]=Y[0bin011110000111]);
-ASSERT(X[0bin011110001000]=X[0bin011110110101]);
-ASSERT(Y[0bin011110001000]=Y[0bin011110110101]);
-ASSERT(X[0bin011110001001]=X[0bin011111100011]);
-ASSERT(Y[0bin011110001001]=Y[0bin011111100011]);
-ASSERT(X[0bin011110001010]=X[0bin100000010001]);
-ASSERT(Y[0bin011110001010]=Y[0bin100000010001]);
-ASSERT(X[0bin011110001011]=X[0bin100000111111]);
-ASSERT(Y[0bin011110001011]=Y[0bin100000111111]);
-ASSERT(X[0bin011110001100]=X[0bin000000101010]);
-ASSERT(Y[0bin011110001100]=Y[0bin000000101010]);
-ASSERT(X[0bin011110001101]=X[0bin000001011000]);
-ASSERT(Y[0bin011110001101]=Y[0bin000001011000]);
-ASSERT(X[0bin011110001110]=X[0bin000010000110]);
-ASSERT(Y[0bin011110001110]=Y[0bin000010000110]);
-ASSERT(X[0bin011110001111]=X[0bin000010110100]);
-ASSERT(Y[0bin011110001111]=Y[0bin000010110100]);
-ASSERT(X[0bin011110010000]=X[0bin000011100010]);
-ASSERT(Y[0bin011110010000]=Y[0bin000011100010]);
-ASSERT(X[0bin011110010001]=X[0bin000100010000]);
-ASSERT(Y[0bin011110010001]=Y[0bin000100010000]);
-ASSERT(X[0bin011110010010]=X[0bin000100111110]);
-ASSERT(Y[0bin011110010010]=Y[0bin000100111110]);
-ASSERT(X[0bin011110010011]=X[0bin000101101100]);
-ASSERT(Y[0bin011110010011]=Y[0bin000101101100]);
-ASSERT(X[0bin011110010100]=X[0bin000110011010]);
-ASSERT(Y[0bin011110010100]=Y[0bin000110011010]);
-ASSERT(X[0bin011110010101]=X[0bin000111001000]);
-ASSERT(Y[0bin011110010101]=Y[0bin000111001000]);
-ASSERT(X[0bin011110010110]=X[0bin000111110110]);
-ASSERT(Y[0bin011110010110]=Y[0bin000111110110]);
-ASSERT(X[0bin011110010111]=X[0bin001000100100]);
-ASSERT(Y[0bin011110010111]=Y[0bin001000100100]);
-ASSERT(X[0bin011110011000]=X[0bin001001010010]);
-ASSERT(Y[0bin011110011000]=Y[0bin001001010010]);
-ASSERT(X[0bin011110011001]=X[0bin001010000000]);
-ASSERT(Y[0bin011110011001]=Y[0bin001010000000]);
-ASSERT(X[0bin011110011010]=X[0bin001010101110]);
-ASSERT(Y[0bin011110011010]=Y[0bin001010101110]);
-ASSERT(X[0bin011110011011]=X[0bin001011011100]);
-ASSERT(Y[0bin011110011011]=Y[0bin001011011100]);
-ASSERT(X[0bin011110011100]=X[0bin001100001010]);
-ASSERT(Y[0bin011110011100]=Y[0bin001100001010]);
-ASSERT(X[0bin011110011101]=X[0bin001100111000]);
-ASSERT(Y[0bin011110011101]=Y[0bin001100111000]);
-ASSERT(X[0bin011110011110]=X[0bin001101100110]);
-ASSERT(Y[0bin011110011110]=Y[0bin001101100110]);
-ASSERT(X[0bin011110011111]=X[0bin001110010100]);
-ASSERT(Y[0bin011110011111]=Y[0bin001110010100]);
-ASSERT(X[0bin011110100000]=X[0bin001111000010]);
-ASSERT(Y[0bin011110100000]=Y[0bin001111000010]);
-ASSERT(X[0bin011110100001]=X[0bin001111110000]);
-ASSERT(Y[0bin011110100001]=Y[0bin001111110000]);
-ASSERT(X[0bin011110100010]=X[0bin010000011110]);
-ASSERT(Y[0bin011110100010]=Y[0bin010000011110]);
-ASSERT(X[0bin011110100011]=X[0bin010001001100]);
-ASSERT(Y[0bin011110100011]=Y[0bin010001001100]);
-ASSERT(X[0bin011110100100]=X[0bin010001111010]);
-ASSERT(Y[0bin011110100100]=Y[0bin010001111010]);
-ASSERT(X[0bin011110100101]=X[0bin010010101000]);
-ASSERT(Y[0bin011110100101]=Y[0bin010010101000]);
-ASSERT(X[0bin011110100110]=X[0bin010011010110]);
-ASSERT(Y[0bin011110100110]=Y[0bin010011010110]);
-ASSERT(X[0bin011110100111]=X[0bin010100000100]);
-ASSERT(Y[0bin011110100111]=Y[0bin010100000100]);
-ASSERT(X[0bin011110101000]=X[0bin010100110010]);
-ASSERT(Y[0bin011110101000]=Y[0bin010100110010]);
-ASSERT(X[0bin011110101001]=X[0bin010101100000]);
-ASSERT(Y[0bin011110101001]=Y[0bin010101100000]);
-ASSERT(X[0bin011110101010]=X[0bin010110001110]);
-ASSERT(Y[0bin011110101010]=Y[0bin010110001110]);
-ASSERT(X[0bin011110101011]=X[0bin010110111100]);
-ASSERT(Y[0bin011110101011]=Y[0bin010110111100]);
-ASSERT(X[0bin011110101100]=X[0bin010111101010]);
-ASSERT(Y[0bin011110101100]=Y[0bin010111101010]);
-ASSERT(X[0bin011110101101]=X[0bin011000011000]);
-ASSERT(Y[0bin011110101101]=Y[0bin011000011000]);
-ASSERT(X[0bin011110101110]=X[0bin011001000110]);
-ASSERT(Y[0bin011110101110]=Y[0bin011001000110]);
-ASSERT(X[0bin011110101111]=X[0bin011001110100]);
-ASSERT(Y[0bin011110101111]=Y[0bin011001110100]);
-ASSERT(X[0bin011110110000]=X[0bin011010100010]);
-ASSERT(Y[0bin011110110000]=Y[0bin011010100010]);
-ASSERT(X[0bin011110110001]=X[0bin011011010000]);
-ASSERT(Y[0bin011110110001]=Y[0bin011011010000]);
-ASSERT(X[0bin011110110010]=X[0bin011011111110]);
-ASSERT(Y[0bin011110110010]=Y[0bin011011111110]);
-ASSERT(X[0bin011110110011]=X[0bin011100101100]);
-ASSERT(Y[0bin011110110011]=Y[0bin011100101100]);
-ASSERT(X[0bin011110110100]=X[0bin011101011010]);
-ASSERT(Y[0bin011110110100]=Y[0bin011101011010]);
-ASSERT(X[0bin011110110101]=X[0bin011110001000]);
-ASSERT(Y[0bin011110110101]=Y[0bin011110001000]);
-ASSERT(X[0bin011110110110]=X[0bin011110110110]);
-ASSERT(Y[0bin011110110110]=Y[0bin011110110110]);
-ASSERT(X[0bin011110110111]=X[0bin011111100100]);
-ASSERT(Y[0bin011110110111]=Y[0bin011111100100]);
-ASSERT(X[0bin011110111000]=X[0bin100000010010]);
-ASSERT(Y[0bin011110111000]=Y[0bin100000010010]);
-ASSERT(X[0bin011110111001]=X[0bin100001000000]);
-ASSERT(Y[0bin011110111001]=Y[0bin100001000000]);
-ASSERT(X[0bin011110111010]=X[0bin000000101011]);
-ASSERT(Y[0bin011110111010]=Y[0bin000000101011]);
-ASSERT(X[0bin011110111011]=X[0bin000001011001]);
-ASSERT(Y[0bin011110111011]=Y[0bin000001011001]);
-ASSERT(X[0bin011110111100]=X[0bin000010000111]);
-ASSERT(Y[0bin011110111100]=Y[0bin000010000111]);
-ASSERT(X[0bin011110111101]=X[0bin000010110101]);
-ASSERT(Y[0bin011110111101]=Y[0bin000010110101]);
-ASSERT(X[0bin011110111110]=X[0bin000011100011]);
-ASSERT(Y[0bin011110111110]=Y[0bin000011100011]);
-ASSERT(X[0bin011110111111]=X[0bin000100010001]);
-ASSERT(Y[0bin011110111111]=Y[0bin000100010001]);
-ASSERT(X[0bin011111000000]=X[0bin000100111111]);
-ASSERT(Y[0bin011111000000]=Y[0bin000100111111]);
-ASSERT(X[0bin011111000001]=X[0bin000101101101]);
-ASSERT(Y[0bin011111000001]=Y[0bin000101101101]);
-ASSERT(X[0bin011111000010]=X[0bin000110011011]);
-ASSERT(Y[0bin011111000010]=Y[0bin000110011011]);
-ASSERT(X[0bin011111000011]=X[0bin000111001001]);
-ASSERT(Y[0bin011111000011]=Y[0bin000111001001]);
-ASSERT(X[0bin011111000100]=X[0bin000111110111]);
-ASSERT(Y[0bin011111000100]=Y[0bin000111110111]);
-ASSERT(X[0bin011111000101]=X[0bin001000100101]);
-ASSERT(Y[0bin011111000101]=Y[0bin001000100101]);
-ASSERT(X[0bin011111000110]=X[0bin001001010011]);
-ASSERT(Y[0bin011111000110]=Y[0bin001001010011]);
-ASSERT(X[0bin011111000111]=X[0bin001010000001]);
-ASSERT(Y[0bin011111000111]=Y[0bin001010000001]);
-ASSERT(X[0bin011111001000]=X[0bin001010101111]);
-ASSERT(Y[0bin011111001000]=Y[0bin001010101111]);
-ASSERT(X[0bin011111001001]=X[0bin001011011101]);
-ASSERT(Y[0bin011111001001]=Y[0bin001011011101]);
-ASSERT(X[0bin011111001010]=X[0bin001100001011]);
-ASSERT(Y[0bin011111001010]=Y[0bin001100001011]);
-ASSERT(X[0bin011111001011]=X[0bin001100111001]);
-ASSERT(Y[0bin011111001011]=Y[0bin001100111001]);
-ASSERT(X[0bin011111001100]=X[0bin001101100111]);
-ASSERT(Y[0bin011111001100]=Y[0bin001101100111]);
-ASSERT(X[0bin011111001101]=X[0bin001110010101]);
-ASSERT(Y[0bin011111001101]=Y[0bin001110010101]);
-ASSERT(X[0bin011111001110]=X[0bin001111000011]);
-ASSERT(Y[0bin011111001110]=Y[0bin001111000011]);
-ASSERT(X[0bin011111001111]=X[0bin001111110001]);
-ASSERT(Y[0bin011111001111]=Y[0bin001111110001]);
-ASSERT(X[0bin011111010000]=X[0bin010000011111]);
-ASSERT(Y[0bin011111010000]=Y[0bin010000011111]);
-ASSERT(X[0bin011111010001]=X[0bin010001001101]);
-ASSERT(Y[0bin011111010001]=Y[0bin010001001101]);
-ASSERT(X[0bin011111010010]=X[0bin010001111011]);
-ASSERT(Y[0bin011111010010]=Y[0bin010001111011]);
-ASSERT(X[0bin011111010011]=X[0bin010010101001]);
-ASSERT(Y[0bin011111010011]=Y[0bin010010101001]);
-ASSERT(X[0bin011111010100]=X[0bin010011010111]);
-ASSERT(Y[0bin011111010100]=Y[0bin010011010111]);
-ASSERT(X[0bin011111010101]=X[0bin010100000101]);
-ASSERT(Y[0bin011111010101]=Y[0bin010100000101]);
-ASSERT(X[0bin011111010110]=X[0bin010100110011]);
-ASSERT(Y[0bin011111010110]=Y[0bin010100110011]);
-ASSERT(X[0bin011111010111]=X[0bin010101100001]);
-ASSERT(Y[0bin011111010111]=Y[0bin010101100001]);
-ASSERT(X[0bin011111011000]=X[0bin010110001111]);
-ASSERT(Y[0bin011111011000]=Y[0bin010110001111]);
-ASSERT(X[0bin011111011001]=X[0bin010110111101]);
-ASSERT(Y[0bin011111011001]=Y[0bin010110111101]);
-ASSERT(X[0bin011111011010]=X[0bin010111101011]);
-ASSERT(Y[0bin011111011010]=Y[0bin010111101011]);
-ASSERT(X[0bin011111011011]=X[0bin011000011001]);
-ASSERT(Y[0bin011111011011]=Y[0bin011000011001]);
-ASSERT(X[0bin011111011100]=X[0bin011001000111]);
-ASSERT(Y[0bin011111011100]=Y[0bin011001000111]);
-ASSERT(X[0bin011111011101]=X[0bin011001110101]);
-ASSERT(Y[0bin011111011101]=Y[0bin011001110101]);
-ASSERT(X[0bin011111011110]=X[0bin011010100011]);
-ASSERT(Y[0bin011111011110]=Y[0bin011010100011]);
-ASSERT(X[0bin011111011111]=X[0bin011011010001]);
-ASSERT(Y[0bin011111011111]=Y[0bin011011010001]);
-ASSERT(X[0bin011111100000]=X[0bin011011111111]);
-ASSERT(Y[0bin011111100000]=Y[0bin011011111111]);
-ASSERT(X[0bin011111100001]=X[0bin011100101101]);
-ASSERT(Y[0bin011111100001]=Y[0bin011100101101]);
-ASSERT(X[0bin011111100010]=X[0bin011101011011]);
-ASSERT(Y[0bin011111100010]=Y[0bin011101011011]);
-ASSERT(X[0bin011111100011]=X[0bin011110001001]);
-ASSERT(Y[0bin011111100011]=Y[0bin011110001001]);
-ASSERT(X[0bin011111100100]=X[0bin011110110111]);
-ASSERT(Y[0bin011111100100]=Y[0bin011110110111]);
-ASSERT(X[0bin011111100101]=X[0bin011111100101]);
-ASSERT(Y[0bin011111100101]=Y[0bin011111100101]);
-ASSERT(X[0bin011111100110]=X[0bin100000010011]);
-ASSERT(Y[0bin011111100110]=Y[0bin100000010011]);
-ASSERT(X[0bin011111100111]=X[0bin100001000001]);
-ASSERT(Y[0bin011111100111]=Y[0bin100001000001]);
-ASSERT(X[0bin011111101000]=X[0bin000000101100]);
-ASSERT(Y[0bin011111101000]=Y[0bin000000101100]);
-ASSERT(X[0bin011111101001]=X[0bin000001011010]);
-ASSERT(Y[0bin011111101001]=Y[0bin000001011010]);
-ASSERT(X[0bin011111101010]=X[0bin000010001000]);
-ASSERT(Y[0bin011111101010]=Y[0bin000010001000]);
-ASSERT(X[0bin011111101011]=X[0bin000010110110]);
-ASSERT(Y[0bin011111101011]=Y[0bin000010110110]);
-ASSERT(X[0bin011111101100]=X[0bin000011100100]);
-ASSERT(Y[0bin011111101100]=Y[0bin000011100100]);
-ASSERT(X[0bin011111101101]=X[0bin000100010010]);
-ASSERT(Y[0bin011111101101]=Y[0bin000100010010]);
-ASSERT(X[0bin011111101110]=X[0bin000101000000]);
-ASSERT(Y[0bin011111101110]=Y[0bin000101000000]);
-ASSERT(X[0bin011111101111]=X[0bin000101101110]);
-ASSERT(Y[0bin011111101111]=Y[0bin000101101110]);
-ASSERT(X[0bin011111110000]=X[0bin000110011100]);
-ASSERT(Y[0bin011111110000]=Y[0bin000110011100]);
-ASSERT(X[0bin011111110001]=X[0bin000111001010]);
-ASSERT(Y[0bin011111110001]=Y[0bin000111001010]);
-ASSERT(X[0bin011111110010]=X[0bin000111111000]);
-ASSERT(Y[0bin011111110010]=Y[0bin000111111000]);
-ASSERT(X[0bin011111110011]=X[0bin001000100110]);
-ASSERT(Y[0bin011111110011]=Y[0bin001000100110]);
-ASSERT(X[0bin011111110100]=X[0bin001001010100]);
-ASSERT(Y[0bin011111110100]=Y[0bin001001010100]);
-ASSERT(X[0bin011111110101]=X[0bin001010000010]);
-ASSERT(Y[0bin011111110101]=Y[0bin001010000010]);
-ASSERT(X[0bin011111110110]=X[0bin001010110000]);
-ASSERT(Y[0bin011111110110]=Y[0bin001010110000]);
-ASSERT(X[0bin011111110111]=X[0bin001011011110]);
-ASSERT(Y[0bin011111110111]=Y[0bin001011011110]);
-ASSERT(X[0bin011111111000]=X[0bin001100001100]);
-ASSERT(Y[0bin011111111000]=Y[0bin001100001100]);
-ASSERT(X[0bin011111111001]=X[0bin001100111010]);
-ASSERT(Y[0bin011111111001]=Y[0bin001100111010]);
-ASSERT(X[0bin011111111010]=X[0bin001101101000]);
-ASSERT(Y[0bin011111111010]=Y[0bin001101101000]);
-ASSERT(X[0bin011111111011]=X[0bin001110010110]);
-ASSERT(Y[0bin011111111011]=Y[0bin001110010110]);
-ASSERT(X[0bin011111111100]=X[0bin001111000100]);
-ASSERT(Y[0bin011111111100]=Y[0bin001111000100]);
-ASSERT(X[0bin011111111101]=X[0bin001111110010]);
-ASSERT(Y[0bin011111111101]=Y[0bin001111110010]);
-ASSERT(X[0bin011111111110]=X[0bin010000100000]);
-ASSERT(Y[0bin011111111110]=Y[0bin010000100000]);
-ASSERT(X[0bin011111111111]=X[0bin010001001110]);
-ASSERT(Y[0bin011111111111]=Y[0bin010001001110]);
-ASSERT(X[0bin100000000000]=X[0bin010001111100]);
-ASSERT(Y[0bin100000000000]=Y[0bin010001111100]);
-ASSERT(X[0bin100000000001]=X[0bin010010101010]);
-ASSERT(Y[0bin100000000001]=Y[0bin010010101010]);
-ASSERT(X[0bin100000000010]=X[0bin010011011000]);
-ASSERT(Y[0bin100000000010]=Y[0bin010011011000]);
-ASSERT(X[0bin100000000011]=X[0bin010100000110]);
-ASSERT(Y[0bin100000000011]=Y[0bin010100000110]);
-ASSERT(X[0bin100000000100]=X[0bin010100110100]);
-ASSERT(Y[0bin100000000100]=Y[0bin010100110100]);
-ASSERT(X[0bin100000000101]=X[0bin010101100010]);
-ASSERT(Y[0bin100000000101]=Y[0bin010101100010]);
-ASSERT(X[0bin100000000110]=X[0bin010110010000]);
-ASSERT(Y[0bin100000000110]=Y[0bin010110010000]);
-ASSERT(X[0bin100000000111]=X[0bin010110111110]);
-ASSERT(Y[0bin100000000111]=Y[0bin010110111110]);
-ASSERT(X[0bin100000001000]=X[0bin010111101100]);
-ASSERT(Y[0bin100000001000]=Y[0bin010111101100]);
-ASSERT(X[0bin100000001001]=X[0bin011000011010]);
-ASSERT(Y[0bin100000001001]=Y[0bin011000011010]);
-ASSERT(X[0bin100000001010]=X[0bin011001001000]);
-ASSERT(Y[0bin100000001010]=Y[0bin011001001000]);
-ASSERT(X[0bin100000001011]=X[0bin011001110110]);
-ASSERT(Y[0bin100000001011]=Y[0bin011001110110]);
-ASSERT(X[0bin100000001100]=X[0bin011010100100]);
-ASSERT(Y[0bin100000001100]=Y[0bin011010100100]);
-ASSERT(X[0bin100000001101]=X[0bin011011010010]);
-ASSERT(Y[0bin100000001101]=Y[0bin011011010010]);
-ASSERT(X[0bin100000001110]=X[0bin011100000000]);
-ASSERT(Y[0bin100000001110]=Y[0bin011100000000]);
-ASSERT(X[0bin100000001111]=X[0bin011100101110]);
-ASSERT(Y[0bin100000001111]=Y[0bin011100101110]);
-ASSERT(X[0bin100000010000]=X[0bin011101011100]);
-ASSERT(Y[0bin100000010000]=Y[0bin011101011100]);
-ASSERT(X[0bin100000010001]=X[0bin011110001010]);
-ASSERT(Y[0bin100000010001]=Y[0bin011110001010]);
-ASSERT(X[0bin100000010010]=X[0bin011110111000]);
-ASSERT(Y[0bin100000010010]=Y[0bin011110111000]);
-ASSERT(X[0bin100000010011]=X[0bin011111100110]);
-ASSERT(Y[0bin100000010011]=Y[0bin011111100110]);
-ASSERT(X[0bin100000010100]=X[0bin100000010100]);
-ASSERT(Y[0bin100000010100]=Y[0bin100000010100]);
-ASSERT(X[0bin100000010101]=X[0bin100001000010]);
-ASSERT(Y[0bin100000010101]=Y[0bin100001000010]);
-ASSERT(X[0bin100000010110]=X[0bin000000101101]);
-ASSERT(Y[0bin100000010110]=Y[0bin000000101101]);
-ASSERT(X[0bin100000010111]=X[0bin000001011011]);
-ASSERT(Y[0bin100000010111]=Y[0bin000001011011]);
-ASSERT(X[0bin100000011000]=X[0bin000010001001]);
-ASSERT(Y[0bin100000011000]=Y[0bin000010001001]);
-ASSERT(X[0bin100000011001]=X[0bin000010110111]);
-ASSERT(Y[0bin100000011001]=Y[0bin000010110111]);
-ASSERT(X[0bin100000011010]=X[0bin000011100101]);
-ASSERT(Y[0bin100000011010]=Y[0bin000011100101]);
-ASSERT(X[0bin100000011011]=X[0bin000100010011]);
-ASSERT(Y[0bin100000011011]=Y[0bin000100010011]);
-ASSERT(X[0bin100000011100]=X[0bin000101000001]);
-ASSERT(Y[0bin100000011100]=Y[0bin000101000001]);
-ASSERT(X[0bin100000011101]=X[0bin000101101111]);
-ASSERT(Y[0bin100000011101]=Y[0bin000101101111]);
-ASSERT(X[0bin100000011110]=X[0bin000110011101]);
-ASSERT(Y[0bin100000011110]=Y[0bin000110011101]);
-ASSERT(X[0bin100000011111]=X[0bin000111001011]);
-ASSERT(Y[0bin100000011111]=Y[0bin000111001011]);
-ASSERT(X[0bin100000100000]=X[0bin000111111001]);
-ASSERT(Y[0bin100000100000]=Y[0bin000111111001]);
-ASSERT(X[0bin100000100001]=X[0bin001000100111]);
-ASSERT(Y[0bin100000100001]=Y[0bin001000100111]);
-ASSERT(X[0bin100000100010]=X[0bin001001010101]);
-ASSERT(Y[0bin100000100010]=Y[0bin001001010101]);
-ASSERT(X[0bin100000100011]=X[0bin001010000011]);
-ASSERT(Y[0bin100000100011]=Y[0bin001010000011]);
-ASSERT(X[0bin100000100100]=X[0bin001010110001]);
-ASSERT(Y[0bin100000100100]=Y[0bin001010110001]);
-ASSERT(X[0bin100000100101]=X[0bin001011011111]);
-ASSERT(Y[0bin100000100101]=Y[0bin001011011111]);
-ASSERT(X[0bin100000100110]=X[0bin001100001101]);
-ASSERT(Y[0bin100000100110]=Y[0bin001100001101]);
-ASSERT(X[0bin100000100111]=X[0bin001100111011]);
-ASSERT(Y[0bin100000100111]=Y[0bin001100111011]);
-ASSERT(X[0bin100000101000]=X[0bin001101101001]);
-ASSERT(Y[0bin100000101000]=Y[0bin001101101001]);
-ASSERT(X[0bin100000101001]=X[0bin001110010111]);
-ASSERT(Y[0bin100000101001]=Y[0bin001110010111]);
-ASSERT(X[0bin100000101010]=X[0bin001111000101]);
-ASSERT(Y[0bin100000101010]=Y[0bin001111000101]);
-ASSERT(X[0bin100000101011]=X[0bin001111110011]);
-ASSERT(Y[0bin100000101011]=Y[0bin001111110011]);
-ASSERT(X[0bin100000101100]=X[0bin010000100001]);
-ASSERT(Y[0bin100000101100]=Y[0bin010000100001]);
-ASSERT(X[0bin100000101101]=X[0bin010001001111]);
-ASSERT(Y[0bin100000101101]=Y[0bin010001001111]);
-ASSERT(X[0bin100000101110]=X[0bin010001111101]);
-ASSERT(Y[0bin100000101110]=Y[0bin010001111101]);
-ASSERT(X[0bin100000101111]=X[0bin010010101011]);
-ASSERT(Y[0bin100000101111]=Y[0bin010010101011]);
-ASSERT(X[0bin100000110000]=X[0bin010011011001]);
-ASSERT(Y[0bin100000110000]=Y[0bin010011011001]);
-ASSERT(X[0bin100000110001]=X[0bin010100000111]);
-ASSERT(Y[0bin100000110001]=Y[0bin010100000111]);
-ASSERT(X[0bin100000110010]=X[0bin010100110101]);
-ASSERT(Y[0bin100000110010]=Y[0bin010100110101]);
-ASSERT(X[0bin100000110011]=X[0bin010101100011]);
-ASSERT(Y[0bin100000110011]=Y[0bin010101100011]);
-ASSERT(X[0bin100000110100]=X[0bin010110010001]);
-ASSERT(Y[0bin100000110100]=Y[0bin010110010001]);
-ASSERT(X[0bin100000110101]=X[0bin010110111111]);
-ASSERT(Y[0bin100000110101]=Y[0bin010110111111]);
-ASSERT(X[0bin100000110110]=X[0bin010111101101]);
-ASSERT(Y[0bin100000110110]=Y[0bin010111101101]);
-ASSERT(X[0bin100000110111]=X[0bin011000011011]);
-ASSERT(Y[0bin100000110111]=Y[0bin011000011011]);
-ASSERT(X[0bin100000111000]=X[0bin011001001001]);
-ASSERT(Y[0bin100000111000]=Y[0bin011001001001]);
-ASSERT(X[0bin100000111001]=X[0bin011001110111]);
-ASSERT(Y[0bin100000111001]=Y[0bin011001110111]);
-ASSERT(X[0bin100000111010]=X[0bin011010100101]);
-ASSERT(Y[0bin100000111010]=Y[0bin011010100101]);
-ASSERT(X[0bin100000111011]=X[0bin011011010011]);
-ASSERT(Y[0bin100000111011]=Y[0bin011011010011]);
-ASSERT(X[0bin100000111100]=X[0bin011100000001]);
-ASSERT(Y[0bin100000111100]=Y[0bin011100000001]);
-ASSERT(X[0bin100000111101]=X[0bin011100101111]);
-ASSERT(Y[0bin100000111101]=Y[0bin011100101111]);
-ASSERT(X[0bin100000111110]=X[0bin011101011101]);
-ASSERT(Y[0bin100000111110]=Y[0bin011101011101]);
-ASSERT(X[0bin100000111111]=X[0bin011110001011]);
-ASSERT(Y[0bin100000111111]=Y[0bin011110001011]);
-ASSERT(X[0bin100001000000]=X[0bin011110111001]);
-ASSERT(Y[0bin100001000000]=Y[0bin011110111001]);
-ASSERT(X[0bin100001000001]=X[0bin011111100111]);
-ASSERT(Y[0bin100001000001]=Y[0bin011111100111]);
-ASSERT(X[0bin100001000010]=X[0bin100000010101]);
-ASSERT(Y[0bin100001000010]=Y[0bin100000010101]);
-ASSERT(X[0bin100001000011]=X[0bin100001000011]);
-ASSERT(Y[0bin100001000011]=Y[0bin100001000011]);
-%%%%%%%%%% (1) %%%%%%%%%%
-ASSERT(X[0bin000000000000]=0bin0);
-ASSERT(X[0bin000000000001]=0bin0);
-ASSERT((X[0bin000000000111] & X[0bin000000110100] = 0bin1) => final_Ex[0bin000000000111]=0bin00100001);
-ASSERT((X[0bin000000000111] & X[0bin000000110100] = 0bin0) => final_Ex[0bin000000000111]=0bin00000000);
-ASSERT((X[0bin000000010000] & X[0bin000000111101] = 0bin1) => final_Ex[0bin000000010000]=0bin00010101);
-ASSERT((X[0bin000000010000] & X[0bin000000111101] = 0bin0) => final_Ex[0bin000000010000]=0bin00000000);
-ASSERT((X[0bin000000010010] & X[0bin000000111111] = 0bin1) => final_Ex[0bin000000010010]=0bin00100001);
-ASSERT((X[0bin000000010010] & X[0bin000000111111] = 0bin0) => final_Ex[0bin000000010010]=0bin00000000);
-ASSERT((X[0bin000000010110] & X[0bin000001000011] = 0bin1) => final_Ex[0bin000000010110]=0bin00100001);
-ASSERT((X[0bin000000010110] & X[0bin000001000011] = 0bin0) => final_Ex[0bin000000010110]=0bin00000000);
-ASSERT((X[0bin000000011001] & X[0bin000001000110] = 0bin1) => final_Ex[0bin000000011001]=0bin00100001);
-ASSERT((X[0bin000000011001] & X[0bin000001000110] = 0bin0) => final_Ex[0bin000000011001]=0bin00000000);
-ASSERT((X[0bin000000011100] & X[0bin000001001001] = 0bin1) => final_Ex[0bin000000011100]=0bin00100001);
-ASSERT((X[0bin000000011100] & X[0bin000001001001] = 0bin0) => final_Ex[0bin000000011100]=0bin00000000);
-ASSERT((X[0bin000000011111] & X[0bin000001001100] = 0bin1) => final_Ex[0bin000000011111]=0bin00010101);
-ASSERT((X[0bin000000011111] & X[0bin000001001100] = 0bin0) => final_Ex[0bin000000011111]=0bin00000000);
-ASSERT((X[0bin000000101011] & X[0bin000001011000] = 0bin1) => final_Ex[0bin000000101011]=0bin00010101);
-ASSERT((X[0bin000000101011] & X[0bin000001011000] = 0bin0) => final_Ex[0bin000000101011]=0bin00000000);
-ASSERT((X[0bin000000101101] & X[0bin000001011010] = 0bin1) => final_Ex[0bin000000101101]=0bin00100001);
-ASSERT((X[0bin000000101101] & X[0bin000001011010] = 0bin0) => final_Ex[0bin000000101101]=0bin00000000);
-ASSERT(X[0bin000000101111]=0bin0);
-ASSERT(X[0bin000000110000]=0bin0);
-ASSERT((X[0bin000000111111] & X[0bin000001101100] = 0bin1) => final_Ex[0bin000000111111]=0bin00010101);
-ASSERT((X[0bin000000111111] & X[0bin000001101100] = 0bin0) => final_Ex[0bin000000111111]=0bin00000000);
-ASSERT((X[0bin000001011010] & X[0bin000010000111] = 0bin1) => final_Ex[0bin000001011010]=0bin00010101);
-ASSERT((X[0bin000001011010] & X[0bin000010000111] = 0bin0) => final_Ex[0bin000001011010]=0bin00000000);
-ASSERT(X[0bin000001011110]=0bin0);
-ASSERT(X[0bin000001011111]=0bin0);
-ASSERT((X[0bin000001101100] & X[0bin000010011001] = 0bin1) => final_Ex[0bin000001101100]=0bin00010101);
-ASSERT((X[0bin000001101100] & X[0bin000010011001] = 0bin0) => final_Ex[0bin000001101100]=0bin00000000);
-ASSERT((X[0bin000001111011] & X[0bin000010101000] = 0bin1) => final_Ex[0bin000001111011]=0bin00010101);
-ASSERT((X[0bin000001111011] & X[0bin000010101000] = 0bin0) => final_Ex[0bin000001111011]=0bin00000000);
-ASSERT((X[0bin000010000111] & X[0bin000010110100] = 0bin1) => final_Ex[0bin000010000111]=0bin00010101);
-ASSERT((X[0bin000010000111] & X[0bin000010110100] = 0bin0) => final_Ex[0bin000010000111]=0bin00000000);
-ASSERT(X[0bin000010001101]=0bin0);
-ASSERT(X[0bin000010001110]=0bin0);
-ASSERT((X[0bin000010010000] & X[0bin000010111101] = 0bin1) => final_Ex[0bin000010010000]=0bin00011000);
-ASSERT((X[0bin000010010000] & X[0bin000010111101] = 0bin0) => final_Ex[0bin000010010000]=0bin00000000);
-ASSERT((X[0bin000010101000] & X[0bin000011010101] = 0bin1) => final_Ex[0bin000010101000]=0bin00011000);
-ASSERT((X[0bin000010101000] & X[0bin000011010101] = 0bin0) => final_Ex[0bin000010101000]=0bin00000000);
-ASSERT((X[0bin000010110000] & X[0bin000011011101] = 0bin1) => final_Ex[0bin000010110000]=0bin00011000);
-ASSERT((X[0bin000010110000] & X[0bin000011011101] = 0bin0) => final_Ex[0bin000010110000]=0bin00000000);
-ASSERT((X[0bin000010110011] & X[0bin000011100000] = 0bin1) => final_Ex[0bin000010110011]=0bin00011000);
-ASSERT((X[0bin000010110011] & X[0bin000011100000] = 0bin0) => final_Ex[0bin000010110011]=0bin00000000);
-ASSERT((X[0bin000010110100] & X[0bin000011100001] = 0bin1) => final_Ex[0bin000010110100]=0bin00011000);
-ASSERT((X[0bin000010110100] & X[0bin000011100001] = 0bin0) => final_Ex[0bin000010110100]=0bin00000000);
-ASSERT(X[0bin000010111100]=0bin0);
-ASSERT(X[0bin000010111101]=0bin0);
-ASSERT((X[0bin000011000111] & X[0bin000011110100] = 0bin1) => final_Ex[0bin000011000111]=0bin00100001);
-ASSERT((X[0bin000011000111] & X[0bin000011110100] = 0bin0) => final_Ex[0bin000011000111]=0bin00000000);
-ASSERT((X[0bin000011001001] & X[0bin000011110110] = 0bin1) => final_Ex[0bin000011001001]=0bin00010101);
-ASSERT((X[0bin000011001001] & X[0bin000011110110] = 0bin0) => final_Ex[0bin000011001001]=0bin00000000);
-ASSERT((X[0bin000011010011] & X[0bin000100000000] = 0bin1) => final_Ex[0bin000011010011]=0bin00100001);
-ASSERT((X[0bin000011010011] & X[0bin000100000000] = 0bin0) => final_Ex[0bin000011010011]=0bin00000000);
-ASSERT((X[0bin000011010101] & X[0bin000100000010] = 0bin1) => final_Ex[0bin000011010101]=0bin00100001);
-ASSERT((X[0bin000011010101] & X[0bin000100000010] = 0bin0) => final_Ex[0bin000011010101]=0bin00000000);
-ASSERT((X[0bin000011011101] & X[0bin000100001010] = 0bin1) => final_Ex[0bin000011011101]=0bin00100001);
-ASSERT((X[0bin000011011101] & X[0bin000100001010] = 0bin0) => final_Ex[0bin000011011101]=0bin00000000);
-ASSERT((X[0bin000011100100] & X[0bin000100010001] = 0bin1) => final_Ex[0bin000011100100]=0bin00010101);
-ASSERT((X[0bin000011100100] & X[0bin000100010001] = 0bin0) => final_Ex[0bin000011100100]=0bin00000000);
-ASSERT((X[0bin000011101010] & X[0bin000100010111] = 0bin1) => final_Ex[0bin000011101010]=0bin00100010);
-ASSERT((X[0bin000011101010] & X[0bin000100010111] = 0bin0) => final_Ex[0bin000011101010]=0bin00000000);
-ASSERT(X[0bin000011101011]=0bin0);
-ASSERT(X[0bin000011101100]=0bin0);
-ASSERT((X[0bin000011101110] & X[0bin000100011011] = 0bin1) => final_Ex[0bin000011101110]=0bin00011001);
-ASSERT((X[0bin000011101110] & X[0bin000100011011] = 0bin0) => final_Ex[0bin000011101110]=0bin00000000);
-ASSERT((X[0bin000011110010] & X[0bin000100011111] = 0bin1) => final_Ex[0bin000011110010]=0bin00011001);
-ASSERT((X[0bin000011110010] & X[0bin000100011111] = 0bin0) => final_Ex[0bin000011110010]=0bin00000000);
-ASSERT((X[0bin000011110011] & X[0bin000100100000] = 0bin1) => final_Ex[0bin000011110011]=0bin00011001);
-ASSERT((X[0bin000011110011] & X[0bin000100100000] = 0bin0) => final_Ex[0bin000011110011]=0bin00000000);
-ASSERT((X[0bin000011110100] & X[0bin000100100001] = 0bin1) => final_Ex[0bin000011110100]=0bin00100010);
-ASSERT((X[0bin000011110100] & X[0bin000100100001] = 0bin0) => final_Ex[0bin000011110100]=0bin00000000);
-ASSERT((X[0bin000011111001] & X[0bin000100100110] = 0bin1) => final_Ex[0bin000011111001]=0bin00100010);
-ASSERT((X[0bin000011111001] & X[0bin000100100110] = 0bin0) => final_Ex[0bin000011111001]=0bin00000000);
-ASSERT((X[0bin000100000000] & X[0bin000100101101] = 0bin1) => final_Ex[0bin000100000000]=0bin00100010);
-ASSERT((X[0bin000100000000] & X[0bin000100101101] = 0bin0) => final_Ex[0bin000100000000]=0bin00000000);
-ASSERT((X[0bin000100010101] & X[0bin000101000010] = 0bin1) => final_Ex[0bin000100010101]=0bin00100001);
-ASSERT((X[0bin000100010101] & X[0bin000101000010] = 0bin0) => final_Ex[0bin000100010101]=0bin00000000);
-ASSERT(X[0bin000100011010]=0bin0);
-ASSERT(X[0bin000100011011]=0bin0);
-ASSERT((X[0bin000100100100] & X[0bin000101010001] = 0bin1) => final_Ex[0bin000100100100]=0bin00010101);
-ASSERT((X[0bin000100100100] & X[0bin000101010001] = 0bin0) => final_Ex[0bin000100100100]=0bin00000000);
-ASSERT((X[0bin000100100110] & X[0bin000101010011] = 0bin1) => final_Ex[0bin000100100110]=0bin00100001);
-ASSERT((X[0bin000100100110] & X[0bin000101010011] = 0bin0) => final_Ex[0bin000100100110]=0bin00000000);
-ASSERT((X[0bin000100101010] & X[0bin000101010111] = 0bin1) => final_Ex[0bin000100101010]=0bin00100001);
-ASSERT((X[0bin000100101010] & X[0bin000101010111] = 0bin0) => final_Ex[0bin000100101010]=0bin00000000);
-ASSERT((X[0bin000100101101] & X[0bin000101011010] = 0bin1) => final_Ex[0bin000100101101]=0bin00100001);
-ASSERT((X[0bin000100101101] & X[0bin000101011010] = 0bin0) => final_Ex[0bin000100101101]=0bin00000000);
-ASSERT((X[0bin000100110000] & X[0bin000101011101] = 0bin1) => final_Ex[0bin000100110000]=0bin00100001);
-ASSERT((X[0bin000100110000] & X[0bin000101011101] = 0bin0) => final_Ex[0bin000100110000]=0bin00000000);
-ASSERT((X[0bin000100110011] & X[0bin000101100000] = 0bin1) => final_Ex[0bin000100110011]=0bin00010101);
-ASSERT((X[0bin000100110011] & X[0bin000101100000] = 0bin0) => final_Ex[0bin000100110011]=0bin00000000);
-ASSERT((X[0bin000100111111] & X[0bin000101101100] = 0bin1) => final_Ex[0bin000100111111]=0bin00010101);
-ASSERT((X[0bin000100111111] & X[0bin000101101100] = 0bin0) => final_Ex[0bin000100111111]=0bin00000000);
-ASSERT((X[0bin000101000001] & X[0bin000101101110] = 0bin1) => final_Ex[0bin000101000001]=0bin00100001);
-ASSERT((X[0bin000101000001] & X[0bin000101101110] = 0bin0) => final_Ex[0bin000101000001]=0bin00000000);
-ASSERT((X[0bin000101001000] & X[0bin000101110101] = 0bin1) => final_Ex[0bin000101001000]=0bin00010101);
-ASSERT((X[0bin000101001000] & X[0bin000101110101] = 0bin0) => final_Ex[0bin000101001000]=0bin00000000);
-ASSERT(X[0bin000101001001]=0bin0);
-ASSERT(X[0bin000101001010]=0bin0);
-ASSERT((X[0bin000101010111] & X[0bin000110000100] = 0bin1) => final_Ex[0bin000101010111]=0bin00001110);
-ASSERT((X[0bin000101010111] & X[0bin000110000100] = 0bin0) => final_Ex[0bin000101010111]=0bin00000000);
-ASSERT((X[0bin000101011010] & X[0bin000110000111] = 0bin1) => final_Ex[0bin000101011010]=0bin00001110);
-ASSERT((X[0bin000101011010] & X[0bin000110000111] = 0bin0) => final_Ex[0bin000101011010]=0bin00000000);
-ASSERT((X[0bin000101100000] & X[0bin000110001101] = 0bin1) => final_Ex[0bin000101100000]=0bin00010101);
-ASSERT((X[0bin000101100000] & X[0bin000110001101] = 0bin0) => final_Ex[0bin000101100000]=0bin00000000);
-ASSERT((X[0bin000101101000] & X[0bin000110010101] = 0bin1) => final_Ex[0bin000101101000]=0bin00010101);
-ASSERT((X[0bin000101101000] & X[0bin000110010101] = 0bin0) => final_Ex[0bin000101101000]=0bin00000000);
-ASSERT((X[0bin000101101010] & X[0bin000110010111] = 0bin1) => final_Ex[0bin000101101010]=0bin00001110);
-ASSERT((X[0bin000101101010] & X[0bin000110010111] = 0bin0) => final_Ex[0bin000101101010]=0bin00000000);
-ASSERT((X[0bin000101101011] & X[0bin000110011000] = 0bin1) => final_Ex[0bin000101101011]=0bin00010101);
-ASSERT((X[0bin000101101011] & X[0bin000110011000] = 0bin0) => final_Ex[0bin000101101011]=0bin00000000);
-ASSERT((X[0bin000101101100] & X[0bin000110011001] = 0bin1) => final_Ex[0bin000101101100]=0bin00010101);
-ASSERT((X[0bin000101101100] & X[0bin000110011001] = 0bin0) => final_Ex[0bin000101101100]=0bin00000000);
-ASSERT(X[0bin000101111000]=0bin0);
-ASSERT(X[0bin000101111001]=0bin0);
-ASSERT((X[0bin000110000001] & X[0bin000110101110] = 0bin1) => final_Ex[0bin000110000001]=0bin00001001);
-ASSERT((X[0bin000110000001] & X[0bin000110101110] = 0bin0) => final_Ex[0bin000110000001]=0bin00000000);
-ASSERT((X[0bin000110010000] & X[0bin000110111101] = 0bin1) => final_Ex[0bin000110010000]=0bin00000110);
-ASSERT((X[0bin000110010000] & X[0bin000110111101] = 0bin0) => final_Ex[0bin000110010000]=0bin00000000);
-ASSERT((X[0bin000110010011] & X[0bin000111000000] = 0bin1) => final_Ex[0bin000110010011]=0bin00000110);
-ASSERT((X[0bin000110010011] & X[0bin000111000000] = 0bin0) => final_Ex[0bin000110010011]=0bin00000000);
-ASSERT((X[0bin000110011100] & X[0bin000111001001] = 0bin1) => final_Ex[0bin000110011100]=0bin00001001);
-ASSERT((X[0bin000110011100] & X[0bin000111001001] = 0bin0) => final_Ex[0bin000110011100]=0bin00000000);
-ASSERT(X[0bin000110100111]=0bin0);
-ASSERT(X[0bin000110101000]=0bin0);
-ASSERT(X[0bin000111010110]=0bin0);
-ASSERT(X[0bin000111010111]=0bin0);
-ASSERT((X[0bin000111011100] & X[0bin001000001001] = 0bin1) => final_Ex[0bin000111011100]=0bin00010101);
-ASSERT((X[0bin000111011100] & X[0bin001000001001] = 0bin0) => final_Ex[0bin000111011100]=0bin00000000);
-ASSERT((X[0bin000111101011] & X[0bin001000011000] = 0bin1) => final_Ex[0bin000111101011]=0bin00010101);
-ASSERT((X[0bin000111101011] & X[0bin001000011000] = 0bin0) => final_Ex[0bin000111101011]=0bin00000000);
-ASSERT((X[0bin000111110111] & X[0bin001000100100] = 0bin1) => final_Ex[0bin000111110111]=0bin00010101);
-ASSERT((X[0bin000111110111] & X[0bin001000100100] = 0bin0) => final_Ex[0bin000111110111]=0bin00000000);
-ASSERT((X[0bin001000000000] & X[0bin001000101101] = 0bin1) => final_Ex[0bin001000000000]=0bin00010101);
-ASSERT((X[0bin001000000000] & X[0bin001000101101] = 0bin0) => final_Ex[0bin001000000000]=0bin00000000);
-ASSERT(X[0bin001000000101]=0bin0);
-ASSERT(X[0bin001000000110]=0bin0);
-ASSERT((X[0bin001000001111] & X[0bin001000111100] = 0bin1) => final_Ex[0bin001000001111]=0bin00001110);
-ASSERT((X[0bin001000001111] & X[0bin001000111100] = 0bin0) => final_Ex[0bin001000001111]=0bin00000000);
-ASSERT((X[0bin001000010010] & X[0bin001000111111] = 0bin1) => final_Ex[0bin001000010010]=0bin00001110);
-ASSERT((X[0bin001000010010] & X[0bin001000111111] = 0bin0) => final_Ex[0bin001000010010]=0bin00000000);
-ASSERT((X[0bin001000011000] & X[0bin001001000101] = 0bin1) => final_Ex[0bin001000011000]=0bin00010101);
-ASSERT((X[0bin001000011000] & X[0bin001001000101] = 0bin0) => final_Ex[0bin001000011000]=0bin00000000);
-ASSERT((X[0bin001000100000] & X[0bin001001001101] = 0bin1) => final_Ex[0bin001000100000]=0bin00010101);
-ASSERT((X[0bin001000100000] & X[0bin001001001101] = 0bin0) => final_Ex[0bin001000100000]=0bin00000000);
-ASSERT((X[0bin001000100010] & X[0bin001001001111] = 0bin1) => final_Ex[0bin001000100010]=0bin00001110);
-ASSERT((X[0bin001000100010] & X[0bin001001001111] = 0bin0) => final_Ex[0bin001000100010]=0bin00000000);
-ASSERT((X[0bin001000100011] & X[0bin001001010000] = 0bin1) => final_Ex[0bin001000100011]=0bin00010101);
-ASSERT((X[0bin001000100011] & X[0bin001001010000] = 0bin0) => final_Ex[0bin001000100011]=0bin00000000);
-ASSERT((X[0bin001000100100] & X[0bin001001010001] = 0bin1) => final_Ex[0bin001000100100]=0bin00010101);
-ASSERT((X[0bin001000100100] & X[0bin001001010001] = 0bin0) => final_Ex[0bin001000100100]=0bin00000000);
-ASSERT((X[0bin001000101110] & X[0bin001001011011] = 0bin1) => final_Ex[0bin001000101110]=0bin00010101);
-ASSERT((X[0bin001000101110] & X[0bin001001011011] = 0bin0) => final_Ex[0bin001000101110]=0bin00000000);
-ASSERT(X[0bin001000110100]=0bin0);
-ASSERT(X[0bin001000110101]=0bin0);
-ASSERT((X[0bin001001000110] & X[0bin001001110011] = 0bin1) => final_Ex[0bin001001000110]=0bin00010101);
-ASSERT((X[0bin001001000110] & X[0bin001001110011] = 0bin0) => final_Ex[0bin001001000110]=0bin00000000);
-ASSERT((X[0bin001001001110] & X[0bin001001111011] = 0bin1) => final_Ex[0bin001001001110]=0bin00010101);
-ASSERT((X[0bin001001001110] & X[0bin001001111011] = 0bin0) => final_Ex[0bin001001001110]=0bin00000000);
-ASSERT((X[0bin001001001111] & X[0bin001001111100] = 0bin1) => final_Ex[0bin001001001111]=0bin00001110);
-ASSERT((X[0bin001001001111] & X[0bin001001111100] = 0bin0) => final_Ex[0bin001001001111]=0bin00000000);
-ASSERT((X[0bin001001010001] & X[0bin001001111110] = 0bin1) => final_Ex[0bin001001010001]=0bin00010101);
-ASSERT((X[0bin001001010001] & X[0bin001001111110] = 0bin0) => final_Ex[0bin001001010001]=0bin00000000);
-ASSERT((X[0bin001001010010] & X[0bin001001111111] = 0bin1) => final_Ex[0bin001001010010]=0bin00010101);
-ASSERT((X[0bin001001010010] & X[0bin001001111111] = 0bin0) => final_Ex[0bin001001010010]=0bin00000000);
-ASSERT((X[0bin001001011100] & X[0bin001010001001] = 0bin1) => final_Ex[0bin001001011100]=0bin00011000);
-ASSERT((X[0bin001001011100] & X[0bin001010001001] = 0bin0) => final_Ex[0bin001001011100]=0bin00000000);
-ASSERT(X[0bin001001100011]=0bin0);
-ASSERT(X[0bin001001100100]=0bin0);
-ASSERT((X[0bin001001110100] & X[0bin001010100001] = 0bin1) => final_Ex[0bin001001110100]=0bin00011000);
-ASSERT((X[0bin001001110100] & X[0bin001010100001] = 0bin0) => final_Ex[0bin001001110100]=0bin00000000);
-ASSERT((X[0bin001001111100] & X[0bin001010101001] = 0bin1) => final_Ex[0bin001001111100]=0bin00011000);
-ASSERT((X[0bin001001111100] & X[0bin001010101001] = 0bin0) => final_Ex[0bin001001111100]=0bin00000000);
-ASSERT((X[0bin001001111111] & X[0bin001010101100] = 0bin1) => final_Ex[0bin001001111111]=0bin00011000);
-ASSERT((X[0bin001001111111] & X[0bin001010101100] = 0bin0) => final_Ex[0bin001001111111]=0bin00000000);
-ASSERT((X[0bin001010000000] & X[0bin001010101101] = 0bin1) => final_Ex[0bin001010000000]=0bin00011000);
-ASSERT((X[0bin001010000000] & X[0bin001010101101] = 0bin0) => final_Ex[0bin001010000000]=0bin00000000);
-ASSERT((X[0bin001010001001] & X[0bin001010110110] = 0bin1) => final_Ex[0bin001010001001]=0bin00100001);
-ASSERT((X[0bin001010001001] & X[0bin001010110110] = 0bin0) => final_Ex[0bin001010001001]=0bin00000000);
-ASSERT(X[0bin001010010010]=0bin0);
-ASSERT(X[0bin001010010011]=0bin0);
-ASSERT((X[0bin001010010101] & X[0bin001011000010] = 0bin1) => final_Ex[0bin001010010101]=0bin00010101);
-ASSERT((X[0bin001010010101] & X[0bin001011000010] = 0bin0) => final_Ex[0bin001010010101]=0bin00000000);
-ASSERT((X[0bin001010011111] & X[0bin001011001100] = 0bin1) => final_Ex[0bin001010011111]=0bin00100001);
-ASSERT((X[0bin001010011111] & X[0bin001011001100] = 0bin0) => final_Ex[0bin001010011111]=0bin00000000);
-ASSERT((X[0bin001010100001] & X[0bin001011001110] = 0bin1) => final_Ex[0bin001010100001]=0bin00100001);
-ASSERT((X[0bin001010100001] & X[0bin001011001110] = 0bin0) => final_Ex[0bin001010100001]=0bin00000000);
-ASSERT((X[0bin001010101001] & X[0bin001011010110] = 0bin1) => final_Ex[0bin001010101001]=0bin00100001);
-ASSERT((X[0bin001010101001] & X[0bin001011010110] = 0bin0) => final_Ex[0bin001010101001]=0bin00000000);
-ASSERT((X[0bin001010110000] & X[0bin001011011101] = 0bin1) => final_Ex[0bin001010110000]=0bin00010101);
-ASSERT((X[0bin001010110000] & X[0bin001011011101] = 0bin0) => final_Ex[0bin001010110000]=0bin00000000);
-ASSERT((X[0bin001010110011] & X[0bin001011100000] = 0bin1) => final_Ex[0bin001010110011]=0bin00011000);
-ASSERT((X[0bin001010110011] & X[0bin001011100000] = 0bin0) => final_Ex[0bin001010110011]=0bin00000000);
-ASSERT((X[0bin001010110101] & X[0bin001011100010] = 0bin1) => final_Ex[0bin001010110101]=0bin00001111);
-ASSERT((X[0bin001010110101] & X[0bin001011100010] = 0bin0) => final_Ex[0bin001010110101]=0bin00000000);
-ASSERT((X[0bin001010111001] & X[0bin001011100110] = 0bin1) => final_Ex[0bin001010111001]=0bin00011000);
-ASSERT((X[0bin001010111001] & X[0bin001011100110] = 0bin0) => final_Ex[0bin001010111001]=0bin00000000);
-ASSERT((X[0bin001010111101] & X[0bin001011101010] = 0bin1) => final_Ex[0bin001010111101]=0bin00001111);
-ASSERT((X[0bin001010111101] & X[0bin001011101010] = 0bin0) => final_Ex[0bin001010111101]=0bin00000000);
-ASSERT(X[0bin001011000001]=0bin0);
-ASSERT(X[0bin001011000010]=0bin0);
-ASSERT((X[0bin001011000100] & X[0bin001011110001] = 0bin1) => final_Ex[0bin001011000100]=0bin00011000);
-ASSERT((X[0bin001011000100] & X[0bin001011110001] = 0bin0) => final_Ex[0bin001011000100]=0bin00000000);
-ASSERT((X[0bin001011001000] & X[0bin001011110101] = 0bin1) => final_Ex[0bin001011001000]=0bin00011000);
-ASSERT((X[0bin001011001000] & X[0bin001011110101] = 0bin0) => final_Ex[0bin001011001000]=0bin00000000);
-ASSERT((X[0bin001011001011] & X[0bin001011111000] = 0bin1) => final_Ex[0bin001011001011]=0bin00011000);
-ASSERT((X[0bin001011001011] & X[0bin001011111000] = 0bin0) => final_Ex[0bin001011001011]=0bin00000000);
-ASSERT((X[0bin001011001110] & X[0bin001011111011] = 0bin1) => final_Ex[0bin001011001110]=0bin00011000);
-ASSERT((X[0bin001011001110] & X[0bin001011111011] = 0bin0) => final_Ex[0bin001011001110]=0bin00000000);
-ASSERT((X[0bin001011010001] & X[0bin001011111110] = 0bin1) => final_Ex[0bin001011010001]=0bin00001101);
-ASSERT((X[0bin001011010001] & X[0bin001011111110] = 0bin0) => final_Ex[0bin001011010001]=0bin00000000);
-ASSERT((X[0bin001011010100] & X[0bin001100000001] = 0bin1) => final_Ex[0bin001011010100]=0bin00000101);
-ASSERT((X[0bin001011010100] & X[0bin001100000001] = 0bin0) => final_Ex[0bin001011010100]=0bin00000000);
-ASSERT((X[0bin001011010110] & X[0bin001100000011] = 0bin1) => final_Ex[0bin001011010110]=0bin00001111);
-ASSERT((X[0bin001011010110] & X[0bin001100000011] = 0bin0) => final_Ex[0bin001011010110]=0bin00000000);
-ASSERT((X[0bin001011011101] & X[0bin001100001010] = 0bin1) => final_Ex[0bin001011011101]=0bin00001101);
-ASSERT((X[0bin001011011101] & X[0bin001100001010] = 0bin0) => final_Ex[0bin001011011101]=0bin00000000);
-ASSERT((X[0bin001011011111] & X[0bin001100001100] = 0bin1) => final_Ex[0bin001011011111]=0bin00011000);
-ASSERT((X[0bin001011011111] & X[0bin001100001100] = 0bin0) => final_Ex[0bin001011011111]=0bin00000000);
-ASSERT((X[0bin001011100010] & X[0bin001100001111] = 0bin1) => final_Ex[0bin001011100010]=0bin00001111);
-ASSERT((X[0bin001011100010] & X[0bin001100001111] = 0bin0) => final_Ex[0bin001011100010]=0bin00000000);
-ASSERT((X[0bin001011100101] & X[0bin001100010010] = 0bin1) => final_Ex[0bin001011100101]=0bin00011000);
-ASSERT((X[0bin001011100101] & X[0bin001100010010] = 0bin0) => final_Ex[0bin001011100101]=0bin00000000);
-ASSERT((X[0bin001011101001] & X[0bin001100010110] = 0bin1) => final_Ex[0bin001011101001]=0bin00000101);
-ASSERT((X[0bin001011101001] & X[0bin001100010110] = 0bin0) => final_Ex[0bin001011101001]=0bin00000000);
-ASSERT((X[0bin001011101111] & X[0bin001100011100] = 0bin1) => final_Ex[0bin001011101111]=0bin00011000);
-ASSERT((X[0bin001011101111] & X[0bin001100011100] = 0bin0) => final_Ex[0bin001011101111]=0bin00000000);
-ASSERT(X[0bin001011110000]=0bin0);
-ASSERT(X[0bin001011110001]=0bin0);
-ASSERT((X[0bin001011110100] & X[0bin001100100001] = 0bin1) => final_Ex[0bin001011110100]=0bin00001111);
-ASSERT((X[0bin001011110100] & X[0bin001100100001] = 0bin0) => final_Ex[0bin001011110100]=0bin00000000);
-ASSERT((X[0bin001011110111] & X[0bin001100100100] = 0bin1) => final_Ex[0bin001011110111]=0bin00001111);
-ASSERT((X[0bin001011110111] & X[0bin001100100100] = 0bin0) => final_Ex[0bin001011110111]=0bin00000000);
-ASSERT((X[0bin001011111011] & X[0bin001100101000] = 0bin1) => final_Ex[0bin001011111011]=0bin00011000);
-ASSERT((X[0bin001011111011] & X[0bin001100101000] = 0bin0) => final_Ex[0bin001011111011]=0bin00000000);
-ASSERT((X[0bin001011111101] & X[0bin001100101010] = 0bin1) => final_Ex[0bin001011111101]=0bin00011000);
-ASSERT((X[0bin001011111101] & X[0bin001100101010] = 0bin0) => final_Ex[0bin001011111101]=0bin00000000);
-ASSERT((X[0bin001100000000] & X[0bin001100101101] = 0bin1) => final_Ex[0bin001100000000]=0bin00000101);
-ASSERT((X[0bin001100000000] & X[0bin001100101101] = 0bin0) => final_Ex[0bin001100000000]=0bin00000000);
-ASSERT((X[0bin001100000011] & X[0bin001100110000] = 0bin1) => final_Ex[0bin001100000011]=0bin00000101);
-ASSERT((X[0bin001100000011] & X[0bin001100110000] = 0bin0) => final_Ex[0bin001100000011]=0bin00000000);
-ASSERT((X[0bin001100000101] & X[0bin001100110010] = 0bin1) => final_Ex[0bin001100000101]=0bin00011000);
-ASSERT((X[0bin001100000101] & X[0bin001100110010] = 0bin0) => final_Ex[0bin001100000101]=0bin00000000);
-ASSERT((X[0bin001100001100] & X[0bin001100111001] = 0bin1) => final_Ex[0bin001100001100]=0bin00001101);
-ASSERT((X[0bin001100001100] & X[0bin001100111001] = 0bin0) => final_Ex[0bin001100001100]=0bin00000000);
-ASSERT((X[0bin001100001111] & X[0bin001100111100] = 0bin1) => final_Ex[0bin001100001111]=0bin00100001);
-ASSERT((X[0bin001100001111] & X[0bin001100111100] = 0bin0) => final_Ex[0bin001100001111]=0bin00000000);
-ASSERT((X[0bin001100010101] & X[0bin001101000010] = 0bin1) => final_Ex[0bin001100010101]=0bin00100001);
-ASSERT((X[0bin001100010101] & X[0bin001101000010] = 0bin0) => final_Ex[0bin001100010101]=0bin00000000);
-ASSERT((X[0bin001100011110] & X[0bin001101001011] = 0bin1) => final_Ex[0bin001100011110]=0bin00010101);
-ASSERT((X[0bin001100011110] & X[0bin001101001011] = 0bin0) => final_Ex[0bin001100011110]=0bin00000000);
-ASSERT(X[0bin001100011111]=0bin0);
-ASSERT(X[0bin001100100000]=0bin0);
-ASSERT((X[0bin001100100100] & X[0bin001101010001] = 0bin1) => final_Ex[0bin001100100100]=0bin00100001);
-ASSERT((X[0bin001100100100] & X[0bin001101010001] = 0bin0) => final_Ex[0bin001100100100]=0bin00000000);
-ASSERT((X[0bin001100100111] & X[0bin001101010100] = 0bin1) => final_Ex[0bin001100100111]=0bin00100001);
-ASSERT((X[0bin001100100111] & X[0bin001101010100] = 0bin0) => final_Ex[0bin001100100111]=0bin00000000);
-ASSERT((X[0bin001100101010] & X[0bin001101010111] = 0bin1) => final_Ex[0bin001100101010]=0bin00100001);
-ASSERT((X[0bin001100101010] & X[0bin001101010111] = 0bin0) => final_Ex[0bin001100101010]=0bin00000000);
-ASSERT((X[0bin001100101101] & X[0bin001101011010] = 0bin1) => final_Ex[0bin001100101101]=0bin00010101);
-ASSERT((X[0bin001100101101] & X[0bin001101011010] = 0bin0) => final_Ex[0bin001100101101]=0bin00000000);
-ASSERT((X[0bin001100111001] & X[0bin001101100110] = 0bin1) => final_Ex[0bin001100111001]=0bin00010101);
-ASSERT((X[0bin001100111001] & X[0bin001101100110] = 0bin0) => final_Ex[0bin001100111001]=0bin00000000);
-ASSERT((X[0bin001100111011] & X[0bin001101101000] = 0bin1) => final_Ex[0bin001100111011]=0bin00100001);
-ASSERT((X[0bin001100111011] & X[0bin001101101000] = 0bin0) => final_Ex[0bin001100111011]=0bin00000000);
-ASSERT((X[0bin001101000010] & X[0bin001101101111] = 0bin1) => final_Ex[0bin001101000010]=0bin00011000);
-ASSERT((X[0bin001101000010] & X[0bin001101101111] = 0bin0) => final_Ex[0bin001101000010]=0bin00000000);
-ASSERT(X[0bin001101001110]=0bin0);
-ASSERT(X[0bin001101001111]=0bin0);
-ASSERT((X[0bin001101011010] & X[0bin001110000111] = 0bin1) => final_Ex[0bin001101011010]=0bin00011000);
-ASSERT((X[0bin001101011010] & X[0bin001110000111] = 0bin0) => final_Ex[0bin001101011010]=0bin00000000);
-ASSERT((X[0bin001101100010] & X[0bin001110001111] = 0bin1) => final_Ex[0bin001101100010]=0bin00011000);
-ASSERT((X[0bin001101100010] & X[0bin001110001111] = 0bin0) => final_Ex[0bin001101100010]=0bin00000000);
-ASSERT((X[0bin001101100101] & X[0bin001110010010] = 0bin1) => final_Ex[0bin001101100101]=0bin00011000);
-ASSERT((X[0bin001101100101] & X[0bin001110010010] = 0bin0) => final_Ex[0bin001101100101]=0bin00000000);
-ASSERT((X[0bin001101100110] & X[0bin001110010011] = 0bin1) => final_Ex[0bin001101100110]=0bin00011000);
-ASSERT((X[0bin001101100110] & X[0bin001110010011] = 0bin0) => final_Ex[0bin001101100110]=0bin00000000);
-ASSERT((X[0bin001101111011] & X[0bin001110101000] = 0bin1) => final_Ex[0bin001101111011]=0bin00010101);
-ASSERT((X[0bin001101111011] & X[0bin001110101000] = 0bin0) => final_Ex[0bin001101111011]=0bin00000000);
-ASSERT(X[0bin001101111101]=0bin0);
-ASSERT(X[0bin001101111110]=0bin0);
-ASSERT((X[0bin001110010110] & X[0bin001111000011] = 0bin1) => final_Ex[0bin001110010110]=0bin00010101);
-ASSERT((X[0bin001110010110] & X[0bin001111000011] = 0bin0) => final_Ex[0bin001110010110]=0bin00000000);
-ASSERT((X[0bin001110100000] & X[0bin001111001101] = 0bin1) => final_Ex[0bin001110100000]=0bin00010110);
-ASSERT((X[0bin001110100000] & X[0bin001111001101] = 0bin0) => final_Ex[0bin001110100000]=0bin00000000);
-ASSERT((X[0bin001110100100] & X[0bin001111010001] = 0bin1) => final_Ex[0bin001110100100]=0bin00010110);
-ASSERT((X[0bin001110100100] & X[0bin001111010001] = 0bin0) => final_Ex[0bin001110100100]=0bin00000000);
-ASSERT(X[0bin001110101100]=0bin0);
-ASSERT(X[0bin001110101101]=0bin0);
-ASSERT((X[0bin001111000111] & X[0bin001111110100] = 0bin1) => final_Ex[0bin001111000111]=0bin00100001);
-ASSERT((X[0bin001111000111] & X[0bin001111110100] = 0bin0) => final_Ex[0bin001111000111]=0bin00000000);
-ASSERT((X[0bin001111001101] & X[0bin001111111010] = 0bin1) => final_Ex[0bin001111001101]=0bin00100001);
-ASSERT((X[0bin001111001101] & X[0bin001111111010] = 0bin0) => final_Ex[0bin001111001101]=0bin00000000);
-ASSERT((X[0bin001111010110] & X[0bin010000000011] = 0bin1) => final_Ex[0bin001111010110]=0bin00010101);
-ASSERT((X[0bin001111010110] & X[0bin010000000011] = 0bin0) => final_Ex[0bin001111010110]=0bin00000000);
-ASSERT((X[0bin001111011000] & X[0bin010000000101] = 0bin1) => final_Ex[0bin001111011000]=0bin00100001);
-ASSERT((X[0bin001111011000] & X[0bin010000000101] = 0bin0) => final_Ex[0bin001111011000]=0bin00000000);
-ASSERT(X[0bin001111011011]=0bin0);
-ASSERT(X[0bin001111011100]=0bin0);
-ASSERT((X[0bin001111011111] & X[0bin010000001100] = 0bin1) => final_Ex[0bin001111011111]=0bin00100001);
-ASSERT((X[0bin001111011111] & X[0bin010000001100] = 0bin0) => final_Ex[0bin001111011111]=0bin00000000);
-ASSERT((X[0bin001111100010] & X[0bin010000001111] = 0bin1) => final_Ex[0bin001111100010]=0bin00100001);
-ASSERT((X[0bin001111100010] & X[0bin010000001111] = 0bin0) => final_Ex[0bin001111100010]=0bin00000000);
-ASSERT((X[0bin001111100101] & X[0bin010000010010] = 0bin1) => final_Ex[0bin001111100101]=0bin00010101);
-ASSERT((X[0bin001111100101] & X[0bin010000010010] = 0bin0) => final_Ex[0bin001111100101]=0bin00000000);
-ASSERT((X[0bin001111110001] & X[0bin010000011110] = 0bin1) => final_Ex[0bin001111110001]=0bin00010101);
-ASSERT((X[0bin001111110001] & X[0bin010000011110] = 0bin0) => final_Ex[0bin001111110001]=0bin00000000);
-ASSERT((X[0bin001111110011] & X[0bin010000100000] = 0bin1) => final_Ex[0bin001111110011]=0bin00100001);
-ASSERT((X[0bin001111110011] & X[0bin010000100000] = 0bin0) => final_Ex[0bin001111110011]=0bin00000000);
-ASSERT((X[0bin010000000101] & X[0bin010000110010] = 0bin1) => final_Ex[0bin010000000101]=0bin00010101);
-ASSERT((X[0bin010000000101] & X[0bin010000110010] = 0bin0) => final_Ex[0bin010000000101]=0bin00000000);
-ASSERT(X[0bin010000001010]=0bin0);
-ASSERT(X[0bin010000001011]=0bin0);
-ASSERT((X[0bin010000100000] & X[0bin010001001101] = 0bin1) => final_Ex[0bin010000100000]=0bin00010101);
-ASSERT((X[0bin010000100000] & X[0bin010001001101] = 0bin0) => final_Ex[0bin010000100000]=0bin00000000);
-ASSERT((X[0bin010000101010] & X[0bin010001010111] = 0bin1) => final_Ex[0bin010000101010]=0bin00010110);
-ASSERT((X[0bin010000101010] & X[0bin010001010111] = 0bin0) => final_Ex[0bin010000101010]=0bin00000000);
-ASSERT((X[0bin010000101110] & X[0bin010001011011] = 0bin1) => final_Ex[0bin010000101110]=0bin00010110);
-ASSERT((X[0bin010000101110] & X[0bin010001011011] = 0bin0) => final_Ex[0bin010000101110]=0bin00000000);
-ASSERT(X[0bin010000111001]=0bin0);
-ASSERT(X[0bin010000111010]=0bin0);
-ASSERT((X[0bin010001010001] & X[0bin010001111110] = 0bin1) => final_Ex[0bin010001010001]=0bin00100001);
-ASSERT((X[0bin010001010001] & X[0bin010001111110] = 0bin0) => final_Ex[0bin010001010001]=0bin00000000);
-ASSERT((X[0bin010001010111] & X[0bin010010000100] = 0bin1) => final_Ex[0bin010001010111]=0bin00100001);
-ASSERT((X[0bin010001010111] & X[0bin010010000100] = 0bin0) => final_Ex[0bin010001010111]=0bin00000000);
-ASSERT((X[0bin010001100000] & X[0bin010010001101] = 0bin1) => final_Ex[0bin010001100000]=0bin00010101);
-ASSERT((X[0bin010001100000] & X[0bin010010001101] = 0bin0) => final_Ex[0bin010001100000]=0bin00000000);
-ASSERT((X[0bin010001100010] & X[0bin010010001111] = 0bin1) => final_Ex[0bin010001100010]=0bin00100001);
-ASSERT((X[0bin010001100010] & X[0bin010010001111] = 0bin0) => final_Ex[0bin010001100010]=0bin00000000);
-ASSERT((X[0bin010001100110] & X[0bin010010010011] = 0bin1) => final_Ex[0bin010001100110]=0bin00100001);
-ASSERT((X[0bin010001100110] & X[0bin010010010011] = 0bin0) => final_Ex[0bin010001100110]=0bin00000000);
-ASSERT(X[0bin010001101000]=0bin0);
-ASSERT(X[0bin010001101001]=0bin0);
-ASSERT((X[0bin010001101100] & X[0bin010010011001] = 0bin1) => final_Ex[0bin010001101100]=0bin00100001);
-ASSERT((X[0bin010001101100] & X[0bin010010011001] = 0bin0) => final_Ex[0bin010001101100]=0bin00000000);
-ASSERT((X[0bin010001101111] & X[0bin010010011100] = 0bin1) => final_Ex[0bin010001101111]=0bin00010101);
-ASSERT((X[0bin010001101111] & X[0bin010010011100] = 0bin0) => final_Ex[0bin010001101111]=0bin00000000);
-ASSERT((X[0bin010001111011] & X[0bin010010101000] = 0bin1) => final_Ex[0bin010001111011]=0bin00010101);
-ASSERT((X[0bin010001111011] & X[0bin010010101000] = 0bin0) => final_Ex[0bin010001111011]=0bin00000000);
-ASSERT((X[0bin010001111101] & X[0bin010010101010] = 0bin1) => final_Ex[0bin010001111101]=0bin00100001);
-ASSERT((X[0bin010001111101] & X[0bin010010101010] = 0bin0) => final_Ex[0bin010001111101]=0bin00000000);
-ASSERT((X[0bin010010000100] & X[0bin010010110001] = 0bin1) => final_Ex[0bin010010000100]=0bin00011000);
-ASSERT((X[0bin010010000100] & X[0bin010010110001] = 0bin0) => final_Ex[0bin010010000100]=0bin00000000);
-ASSERT(X[0bin010010010111]=0bin0);
-ASSERT(X[0bin010010011000]=0bin0);
-ASSERT((X[0bin010010011100] & X[0bin010011001001] = 0bin1) => final_Ex[0bin010010011100]=0bin00011000);
-ASSERT((X[0bin010010011100] & X[0bin010011001001] = 0bin0) => final_Ex[0bin010010011100]=0bin00000000);
-ASSERT((X[0bin010010100100] & X[0bin010011010001] = 0bin1) => final_Ex[0bin010010100100]=0bin00011000);
-ASSERT((X[0bin010010100100] & X[0bin010011010001] = 0bin0) => final_Ex[0bin010010100100]=0bin00000000);
-ASSERT((X[0bin010010100111] & X[0bin010011010100] = 0bin1) => final_Ex[0bin010010100111]=0bin00011000);
-ASSERT((X[0bin010010100111] & X[0bin010011010100] = 0bin0) => final_Ex[0bin010010100111]=0bin00000000);
-ASSERT((X[0bin010010101000] & X[0bin010011010101] = 0bin1) => final_Ex[0bin010010101000]=0bin00011000);
-ASSERT((X[0bin010010101000] & X[0bin010011010101] = 0bin0) => final_Ex[0bin010010101000]=0bin00000000);
-ASSERT((X[0bin010010110001] & X[0bin010011011110] = 0bin1) => final_Ex[0bin010010110001]=0bin00100001);
-ASSERT((X[0bin010010110001] & X[0bin010011011110] = 0bin0) => final_Ex[0bin010010110001]=0bin00000000);
-ASSERT((X[0bin010010111011] & X[0bin010011101000] = 0bin1) => final_Ex[0bin010010111011]=0bin00100001);
-ASSERT((X[0bin010010111011] & X[0bin010011101000] = 0bin0) => final_Ex[0bin010010111011]=0bin00000000);
-ASSERT((X[0bin010010111101] & X[0bin010011101010] = 0bin1) => final_Ex[0bin010010111101]=0bin00010101);
-ASSERT((X[0bin010010111101] & X[0bin010011101010] = 0bin0) => final_Ex[0bin010010111101]=0bin00000000);
-ASSERT(X[0bin010011000110]=0bin0);
-ASSERT(X[0bin010011000111]=0bin0);
-ASSERT((X[0bin010011001001] & X[0bin010011110110] = 0bin1) => final_Ex[0bin010011001001]=0bin00100001);
-ASSERT((X[0bin010011001001] & X[0bin010011110110] = 0bin0) => final_Ex[0bin010011001001]=0bin00000000);
-ASSERT((X[0bin010011010001] & X[0bin010011111110] = 0bin1) => final_Ex[0bin010011010001]=0bin00100001);
-ASSERT((X[0bin010011010001] & X[0bin010011111110] = 0bin0) => final_Ex[0bin010011010001]=0bin00000000);
-ASSERT((X[0bin010011011000] & X[0bin010100000101] = 0bin1) => final_Ex[0bin010011011000]=0bin00010101);
-ASSERT((X[0bin010011011000] & X[0bin010100000101] = 0bin0) => final_Ex[0bin010011011000]=0bin00000000);
-ASSERT((X[0bin010011011011] & X[0bin010100001000] = 0bin1) => final_Ex[0bin010011011011]=0bin00100001);
-ASSERT((X[0bin010011011011] & X[0bin010100001000] = 0bin0) => final_Ex[0bin010011011011]=0bin00000000);
-ASSERT((X[0bin010011100001] & X[0bin010100001110] = 0bin1) => final_Ex[0bin010011100001]=0bin00100001);
-ASSERT((X[0bin010011100001] & X[0bin010100001110] = 0bin0) => final_Ex[0bin010011100001]=0bin00000000);
-ASSERT((X[0bin010011101010] & X[0bin010100010111] = 0bin1) => final_Ex[0bin010011101010]=0bin00010101);
-ASSERT((X[0bin010011101010] & X[0bin010100010111] = 0bin0) => final_Ex[0bin010011101010]=0bin00000000);
-ASSERT((X[0bin010011101100] & X[0bin010100011001] = 0bin1) => final_Ex[0bin010011101100]=0bin00100001);
-ASSERT((X[0bin010011101100] & X[0bin010100011001] = 0bin0) => final_Ex[0bin010011101100]=0bin00000000);
-ASSERT((X[0bin010011110000] & X[0bin010100011101] = 0bin1) => final_Ex[0bin010011110000]=0bin00100001);
-ASSERT((X[0bin010011110000] & X[0bin010100011101] = 0bin0) => final_Ex[0bin010011110000]=0bin00000000);
-ASSERT((X[0bin010011110011] & X[0bin010100100000] = 0bin1) => final_Ex[0bin010011110011]=0bin00100001);
-ASSERT((X[0bin010011110011] & X[0bin010100100000] = 0bin0) => final_Ex[0bin010011110011]=0bin00000000);
-ASSERT(X[0bin010011110101]=0bin0);
-ASSERT(X[0bin010011110110]=0bin0);
-ASSERT((X[0bin010011111001] & X[0bin010100100110] = 0bin1) => final_Ex[0bin010011111001]=0bin00010101);
-ASSERT((X[0bin010011111001] & X[0bin010100100110] = 0bin0) => final_Ex[0bin010011111001]=0bin00000000);
-ASSERT((X[0bin010100000101] & X[0bin010100110010] = 0bin1) => final_Ex[0bin010100000101]=0bin00010101);
-ASSERT((X[0bin010100000101] & X[0bin010100110010] = 0bin0) => final_Ex[0bin010100000101]=0bin00000000);
-ASSERT((X[0bin010100000111] & X[0bin010100110100] = 0bin1) => final_Ex[0bin010100000111]=0bin00100001);
-ASSERT((X[0bin010100000111] & X[0bin010100110100] = 0bin0) => final_Ex[0bin010100000111]=0bin00000000);
-ASSERT((X[0bin010100001101] & X[0bin010100111010] = 0bin1) => final_Ex[0bin010100001101]=0bin00100001);
-ASSERT((X[0bin010100001101] & X[0bin010100111010] = 0bin0) => final_Ex[0bin010100001101]=0bin00000000);
-ASSERT((X[0bin010100010111] & X[0bin010101000100] = 0bin1) => final_Ex[0bin010100010111]=0bin00100001);
-ASSERT((X[0bin010100010111] & X[0bin010101000100] = 0bin0) => final_Ex[0bin010100010111]=0bin00000000);
-ASSERT((X[0bin010100011001] & X[0bin010101000110] = 0bin1) => final_Ex[0bin010100011001]=0bin00010101);
-ASSERT((X[0bin010100011001] & X[0bin010101000110] = 0bin0) => final_Ex[0bin010100011001]=0bin00000000);
-ASSERT((X[0bin010100100011] & X[0bin010101010000] = 0bin1) => final_Ex[0bin010100100011]=0bin00100001);
-ASSERT((X[0bin010100100011] & X[0bin010101010000] = 0bin0) => final_Ex[0bin010100100011]=0bin00000000);
-ASSERT(X[0bin010100100100]=0bin0);
-ASSERT(X[0bin010100100101]=0bin0);
-ASSERT((X[0bin010100101101] & X[0bin010101011010] = 0bin1) => final_Ex[0bin010100101101]=0bin00100001);
-ASSERT((X[0bin010100101101] & X[0bin010101011010] = 0bin0) => final_Ex[0bin010100101101]=0bin00000000);
-ASSERT((X[0bin010100110100] & X[0bin010101100001] = 0bin1) => final_Ex[0bin010100110100]=0bin00010101);
-ASSERT((X[0bin010100110100] & X[0bin010101100001] = 0bin0) => final_Ex[0bin010100110100]=0bin00000000);
-ASSERT((X[0bin010100111010] & X[0bin010101100111] = 0bin1) => final_Ex[0bin010100111010]=0bin00100010);
-ASSERT((X[0bin010100111010] & X[0bin010101100111] = 0bin0) => final_Ex[0bin010100111010]=0bin00000000);
-ASSERT((X[0bin010100111110] & X[0bin010101101011] = 0bin1) => final_Ex[0bin010100111110]=0bin00011001);
-ASSERT((X[0bin010100111110] & X[0bin010101101011] = 0bin0) => final_Ex[0bin010100111110]=0bin00000000);
-ASSERT((X[0bin010101000010] & X[0bin010101101111] = 0bin1) => final_Ex[0bin010101000010]=0bin00011001);
-ASSERT((X[0bin010101000010] & X[0bin010101101111] = 0bin0) => final_Ex[0bin010101000010]=0bin00000000);
-ASSERT((X[0bin010101000011] & X[0bin010101110000] = 0bin1) => final_Ex[0bin010101000011]=0bin00011001);
-ASSERT((X[0bin010101000011] & X[0bin010101110000] = 0bin0) => final_Ex[0bin010101000011]=0bin00000000);
-ASSERT((X[0bin010101000100] & X[0bin010101110001] = 0bin1) => final_Ex[0bin010101000100]=0bin00100010);
-ASSERT((X[0bin010101000100] & X[0bin010101110001] = 0bin0) => final_Ex[0bin010101000100]=0bin00000000);
-ASSERT((X[0bin010101001001] & X[0bin010101110110] = 0bin1) => final_Ex[0bin010101001001]=0bin00100010);
-ASSERT((X[0bin010101001001] & X[0bin010101110110] = 0bin0) => final_Ex[0bin010101001001]=0bin00000000);
-ASSERT((X[0bin010101010000] & X[0bin010101111101] = 0bin1) => final_Ex[0bin010101010000]=0bin00100010);
-ASSERT((X[0bin010101010000] & X[0bin010101111101] = 0bin0) => final_Ex[0bin010101010000]=0bin00000000);
-ASSERT(X[0bin010101010011]=0bin0);
-ASSERT(X[0bin010101010100]=0bin0);
-ASSERT((X[0bin010101100101] & X[0bin010110010010] = 0bin1) => final_Ex[0bin010101100101]=0bin00011000);
-ASSERT((X[0bin010101100101] & X[0bin010110010010] = 0bin0) => final_Ex[0bin010101100101]=0bin00000000);
-ASSERT((X[0bin010101100111] & X[0bin010110010100] = 0bin1) => final_Ex[0bin010101100111]=0bin00001111);
-ASSERT((X[0bin010101100111] & X[0bin010110010100] = 0bin0) => final_Ex[0bin010101100111]=0bin00000000);
-ASSERT((X[0bin010101101011] & X[0bin010110011000] = 0bin1) => final_Ex[0bin010101101011]=0bin00011000);
-ASSERT((X[0bin010101101011] & X[0bin010110011000] = 0bin0) => final_Ex[0bin010101101011]=0bin00000000);
-ASSERT((X[0bin010101101111] & X[0bin010110011100] = 0bin1) => final_Ex[0bin010101101111]=0bin00001111);
-ASSERT((X[0bin010101101111] & X[0bin010110011100] = 0bin0) => final_Ex[0bin010101101111]=0bin00000000);
-ASSERT((X[0bin010101110100] & X[0bin010110100001] = 0bin1) => final_Ex[0bin010101110100]=0bin00001101);
-ASSERT((X[0bin010101110100] & X[0bin010110100001] = 0bin0) => final_Ex[0bin010101110100]=0bin00000000);
-ASSERT((X[0bin010101110110] & X[0bin010110100011] = 0bin1) => final_Ex[0bin010101110110]=0bin00011000);
-ASSERT((X[0bin010101110110] & X[0bin010110100011] = 0bin0) => final_Ex[0bin010101110110]=0bin00000000);
-ASSERT((X[0bin010101111010] & X[0bin010110100111] = 0bin1) => final_Ex[0bin010101111010]=0bin00011000);
-ASSERT((X[0bin010101111010] & X[0bin010110100111] = 0bin0) => final_Ex[0bin010101111010]=0bin00000000);
-ASSERT((X[0bin010101111101] & X[0bin010110101010] = 0bin1) => final_Ex[0bin010101111101]=0bin00011000);
-ASSERT((X[0bin010101111101] & X[0bin010110101010] = 0bin0) => final_Ex[0bin010101111101]=0bin00000000);
-ASSERT((X[0bin010110000000] & X[0bin010110101101] = 0bin1) => final_Ex[0bin010110000000]=0bin00011000);
-ASSERT((X[0bin010110000000] & X[0bin010110101101] = 0bin0) => final_Ex[0bin010110000000]=0bin00000000);
-ASSERT(X[0bin010110000010]=0bin0);
-ASSERT(X[0bin010110000011]=0bin0);
-ASSERT((X[0bin010110000110] & X[0bin010110110011] = 0bin1) => final_Ex[0bin010110000110]=0bin00000101);
-ASSERT((X[0bin010110000110] & X[0bin010110110011] = 0bin0) => final_Ex[0bin010110000110]=0bin00000000);
-ASSERT((X[0bin010110001000] & X[0bin010110110101] = 0bin1) => final_Ex[0bin010110001000]=0bin00001111);
-ASSERT((X[0bin010110001000] & X[0bin010110110101] = 0bin0) => final_Ex[0bin010110001000]=0bin00000000);
-ASSERT((X[0bin010110001111] & X[0bin010110111100] = 0bin1) => final_Ex[0bin010110001111]=0bin00001101);
-ASSERT((X[0bin010110001111] & X[0bin010110111100] = 0bin0) => final_Ex[0bin010110001111]=0bin00000000);
-ASSERT((X[0bin010110010001] & X[0bin010110111110] = 0bin1) => final_Ex[0bin010110010001]=0bin00011000);
-ASSERT((X[0bin010110010001] & X[0bin010110111110] = 0bin0) => final_Ex[0bin010110010001]=0bin00000000);
-ASSERT((X[0bin010110011011] & X[0bin010111001000] = 0bin1) => final_Ex[0bin010110011011]=0bin00000110);
-ASSERT((X[0bin010110011011] & X[0bin010111001000] = 0bin0) => final_Ex[0bin010110011011]=0bin00000000);
-ASSERT((X[0bin010110100011] & X[0bin010111010000] = 0bin1) => final_Ex[0bin010110100011]=0bin00001001);
-ASSERT((X[0bin010110100011] & X[0bin010111010000] = 0bin0) => final_Ex[0bin010110100011]=0bin00000000);
-ASSERT(X[0bin010110110001]=0bin0);
-ASSERT(X[0bin010110110010]=0bin0);
-ASSERT((X[0bin010110110101] & X[0bin010111100010] = 0bin1) => final_Ex[0bin010110110101]=0bin00000110);
-ASSERT((X[0bin010110110101] & X[0bin010111100010] = 0bin0) => final_Ex[0bin010110110101]=0bin00000000);
-ASSERT((X[0bin010110111110] & X[0bin010111101011] = 0bin1) => final_Ex[0bin010110111110]=0bin00001001);
-ASSERT((X[0bin010110111110] & X[0bin010111101011] = 0bin0) => final_Ex[0bin010110111110]=0bin00000000);
-ASSERT(X[0bin010111100000]=0bin0);
-ASSERT(X[0bin010111100001]=0bin0);
-ASSERT((X[0bin010111111110] & X[0bin011000101011] = 0bin1) => final_Ex[0bin010111111110]=0bin00001001);
-ASSERT((X[0bin010111111110] & X[0bin011000101011] = 0bin0) => final_Ex[0bin010111111110]=0bin00000000);
-ASSERT((X[0bin011000001101] & X[0bin011000111010] = 0bin1) => final_Ex[0bin011000001101]=0bin00001001);
-ASSERT((X[0bin011000001101] & X[0bin011000111010] = 0bin0) => final_Ex[0bin011000001101]=0bin00000000);
-ASSERT(X[0bin011000001111]=0bin0);
-ASSERT(X[0bin011000010000]=0bin0);
-ASSERT((X[0bin011000011001] & X[0bin011001000110] = 0bin1) => final_Ex[0bin011000011001]=0bin00001001);
-ASSERT((X[0bin011000011001] & X[0bin011001000110] = 0bin0) => final_Ex[0bin011000011001]=0bin00000000);
-ASSERT((X[0bin011000100101] & X[0bin011001010010] = 0bin1) => final_Ex[0bin011000100101]=0bin00000110);
-ASSERT((X[0bin011000100101] & X[0bin011001010010] = 0bin0) => final_Ex[0bin011000100101]=0bin00000000);
-ASSERT((X[0bin011000101101] & X[0bin011001011010] = 0bin1) => final_Ex[0bin011000101101]=0bin00001001);
-ASSERT((X[0bin011000101101] & X[0bin011001011010] = 0bin0) => final_Ex[0bin011000101101]=0bin00000000);
-ASSERT((X[0bin011000111100] & X[0bin011001101001] = 0bin1) => final_Ex[0bin011000111100]=0bin00000110);
-ASSERT((X[0bin011000111100] & X[0bin011001101001] = 0bin0) => final_Ex[0bin011000111100]=0bin00000000);
-ASSERT(X[0bin011000111110]=0bin0);
-ASSERT(X[0bin011000111111]=0bin0);
-ASSERT((X[0bin011001001000] & X[0bin011001110101] = 0bin1) => final_Ex[0bin011001001000]=0bin00001001);
-ASSERT((X[0bin011001001000] & X[0bin011001110101] = 0bin0) => final_Ex[0bin011001001000]=0bin00000000);
-ASSERT((X[0bin011001011010] & X[0bin011010000111] = 0bin1) => final_Ex[0bin011001011010]=0bin00010101);
-ASSERT((X[0bin011001011010] & X[0bin011010000111] = 0bin0) => final_Ex[0bin011001011010]=0bin00000000);
-ASSERT((X[0bin011001101001] & X[0bin011010010110] = 0bin1) => final_Ex[0bin011001101001]=0bin00010101);
-ASSERT((X[0bin011001101001] & X[0bin011010010110] = 0bin0) => final_Ex[0bin011001101001]=0bin00000000);
-ASSERT(X[0bin011001101101]=0bin0);
-ASSERT(X[0bin011001101110]=0bin0);
-ASSERT((X[0bin011001110101] & X[0bin011010100010] = 0bin1) => final_Ex[0bin011001110101]=0bin00010101);
-ASSERT((X[0bin011001110101] & X[0bin011010100010] = 0bin0) => final_Ex[0bin011001110101]=0bin00000000);
-ASSERT((X[0bin011001111101] & X[0bin011010101010] = 0bin1) => final_Ex[0bin011001111101]=0bin00100001);
-ASSERT((X[0bin011001111101] & X[0bin011010101010] = 0bin0) => final_Ex[0bin011001111101]=0bin00000000);
-ASSERT((X[0bin011010000111] & X[0bin011010110100] = 0bin1) => final_Ex[0bin011010000111]=0bin00100001);
-ASSERT((X[0bin011010000111] & X[0bin011010110100] = 0bin0) => final_Ex[0bin011010000111]=0bin00000000);
-ASSERT((X[0bin011010001001] & X[0bin011010110110] = 0bin1) => final_Ex[0bin011010001001]=0bin00010101);
-ASSERT((X[0bin011010001001] & X[0bin011010110110] = 0bin0) => final_Ex[0bin011010001001]=0bin00000000);
-ASSERT((X[0bin011010010011] & X[0bin011011000000] = 0bin1) => final_Ex[0bin011010010011]=0bin00100001);
-ASSERT((X[0bin011010010011] & X[0bin011011000000] = 0bin0) => final_Ex[0bin011010010011]=0bin00000000);
-ASSERT((X[0bin011010010101] & X[0bin011011000010] = 0bin1) => final_Ex[0bin011010010101]=0bin00100001);
-ASSERT((X[0bin011010010101] & X[0bin011011000010] = 0bin0) => final_Ex[0bin011010010101]=0bin00000000);
-ASSERT(X[0bin011010011100]=0bin0);
-ASSERT(X[0bin011010011101]=0bin0);
-ASSERT((X[0bin011010100100] & X[0bin011011010001] = 0bin1) => final_Ex[0bin011010100100]=0bin00010101);
-ASSERT((X[0bin011010100100] & X[0bin011011010001] = 0bin0) => final_Ex[0bin011010100100]=0bin00000000);
-ASSERT((X[0bin011010101010] & X[0bin011011010111] = 0bin1) => final_Ex[0bin011010101010]=0bin00100010);
-ASSERT((X[0bin011010101010] & X[0bin011011010111] = 0bin0) => final_Ex[0bin011010101010]=0bin00000000);
-ASSERT((X[0bin011010101110] & X[0bin011011011011] = 0bin1) => final_Ex[0bin011010101110]=0bin00011001);
-ASSERT((X[0bin011010101110] & X[0bin011011011011] = 0bin0) => final_Ex[0bin011010101110]=0bin00000000);
-ASSERT((X[0bin011010110010] & X[0bin011011011111] = 0bin1) => final_Ex[0bin011010110010]=0bin00011001);
-ASSERT((X[0bin011010110010] & X[0bin011011011111] = 0bin0) => final_Ex[0bin011010110010]=0bin00000000);
-ASSERT((X[0bin011010110011] & X[0bin011011100000] = 0bin1) => final_Ex[0bin011010110011]=0bin00011001);
-ASSERT((X[0bin011010110011] & X[0bin011011100000] = 0bin0) => final_Ex[0bin011010110011]=0bin00000000);
-ASSERT((X[0bin011010110100] & X[0bin011011100001] = 0bin1) => final_Ex[0bin011010110100]=0bin00100010);
-ASSERT((X[0bin011010110100] & X[0bin011011100001] = 0bin0) => final_Ex[0bin011010110100]=0bin00000000);
-ASSERT((X[0bin011010111001] & X[0bin011011100110] = 0bin1) => final_Ex[0bin011010111001]=0bin00100010);
-ASSERT((X[0bin011010111001] & X[0bin011011100110] = 0bin0) => final_Ex[0bin011010111001]=0bin00000000);
-ASSERT((X[0bin011011000000] & X[0bin011011101101] = 0bin1) => final_Ex[0bin011011000000]=0bin00100010);
-ASSERT((X[0bin011011000000] & X[0bin011011101101] = 0bin0) => final_Ex[0bin011011000000]=0bin00000000);
-ASSERT(X[0bin011011001011]=0bin0);
-ASSERT(X[0bin011011001100]=0bin0);
-ASSERT((X[0bin011011100001] & X[0bin011100001110] = 0bin1) => final_Ex[0bin011011100001]=0bin00010110);
-ASSERT((X[0bin011011100001] & X[0bin011100001110] = 0bin0) => final_Ex[0bin011011100001]=0bin00000000);
-ASSERT(X[0bin011011111010]=0bin0);
-ASSERT(X[0bin011011111011]=0bin0);
-ASSERT((X[0bin011100001010] & X[0bin011100110111] = 0bin1) => final_Ex[0bin011100001010]=0bin00010110);
-ASSERT((X[0bin011100001010] & X[0bin011100110111] = 0bin0) => final_Ex[0bin011100001010]=0bin00000000);
-ASSERT((X[0bin011100001110] & X[0bin011100111011] = 0bin1) => final_Ex[0bin011100001110]=0bin00010110);
-ASSERT((X[0bin011100001110] & X[0bin011100111011] = 0bin0) => final_Ex[0bin011100001110]=0bin00000000);
-ASSERT(X[0bin011100101001]=0bin0);
-ASSERT(X[0bin011100101010]=0bin0);
-ASSERT((X[0bin011100110100] & X[0bin011101100001] = 0bin1) => final_Ex[0bin011100110100]=0bin00100010);
-ASSERT((X[0bin011100110100] & X[0bin011101100001] = 0bin0) => final_Ex[0bin011100110100]=0bin00000000);
-ASSERT((X[0bin011100111000] & X[0bin011101100101] = 0bin1) => final_Ex[0bin011100111000]=0bin00011001);
-ASSERT((X[0bin011100111000] & X[0bin011101100101] = 0bin0) => final_Ex[0bin011100111000]=0bin00000000);
-ASSERT((X[0bin011100111100] & X[0bin011101101001] = 0bin1) => final_Ex[0bin011100111100]=0bin00011001);
-ASSERT((X[0bin011100111100] & X[0bin011101101001] = 0bin0) => final_Ex[0bin011100111100]=0bin00000000);
-ASSERT((X[0bin011100111101] & X[0bin011101101010] = 0bin1) => final_Ex[0bin011100111101]=0bin00011001);
-ASSERT((X[0bin011100111101] & X[0bin011101101010] = 0bin0) => final_Ex[0bin011100111101]=0bin00000000);
-ASSERT((X[0bin011100111110] & X[0bin011101101011] = 0bin1) => final_Ex[0bin011100111110]=0bin00100010);
-ASSERT((X[0bin011100111110] & X[0bin011101101011] = 0bin0) => final_Ex[0bin011100111110]=0bin00000000);
-ASSERT((X[0bin011101000011] & X[0bin011101110000] = 0bin1) => final_Ex[0bin011101000011]=0bin00100010);
-ASSERT((X[0bin011101000011] & X[0bin011101110000] = 0bin0) => final_Ex[0bin011101000011]=0bin00000000);
-ASSERT((X[0bin011101001010] & X[0bin011101110111] = 0bin1) => final_Ex[0bin011101001010]=0bin00100010);
-ASSERT((X[0bin011101001010] & X[0bin011101110111] = 0bin0) => final_Ex[0bin011101001010]=0bin00000000);
-ASSERT(X[0bin011101011000]=0bin0);
-ASSERT(X[0bin011101011001]=0bin0);
-ASSERT((X[0bin011101100010] & X[0bin011110001111] = 0bin1) => final_Ex[0bin011101100010]=0bin00100010);
-ASSERT((X[0bin011101100010] & X[0bin011110001111] = 0bin0) => final_Ex[0bin011101100010]=0bin00000000);
-ASSERT((X[0bin011101100110] & X[0bin011110010011] = 0bin1) => final_Ex[0bin011101100110]=0bin00011001);
-ASSERT((X[0bin011101100110] & X[0bin011110010011] = 0bin0) => final_Ex[0bin011101100110]=0bin00000000);
-ASSERT((X[0bin011101101010] & X[0bin011110010111] = 0bin1) => final_Ex[0bin011101101010]=0bin00011001);
-ASSERT((X[0bin011101101010] & X[0bin011110010111] = 0bin0) => final_Ex[0bin011101101010]=0bin00000000);
-ASSERT((X[0bin011101101011] & X[0bin011110011000] = 0bin1) => final_Ex[0bin011101101011]=0bin00011001);
-ASSERT((X[0bin011101101011] & X[0bin011110011000] = 0bin0) => final_Ex[0bin011101101011]=0bin00000000);
-ASSERT((X[0bin011101101100] & X[0bin011110011001] = 0bin1) => final_Ex[0bin011101101100]=0bin00100010);
-ASSERT((X[0bin011101101100] & X[0bin011110011001] = 0bin0) => final_Ex[0bin011101101100]=0bin00000000);
-ASSERT((X[0bin011101110001] & X[0bin011110011110] = 0bin1) => final_Ex[0bin011101110001]=0bin00100010);
-ASSERT((X[0bin011101110001] & X[0bin011110011110] = 0bin0) => final_Ex[0bin011101110001]=0bin00000000);
-ASSERT((X[0bin011101111000] & X[0bin011110100101] = 0bin1) => final_Ex[0bin011101111000]=0bin00100010);
-ASSERT((X[0bin011101111000] & X[0bin011110100101] = 0bin0) => final_Ex[0bin011101111000]=0bin00000000);
-ASSERT(X[0bin011110000111]=0bin0);
-ASSERT(X[0bin011110001000]=0bin0);
-ASSERT((X[0bin011110001101] & X[0bin011110111010] = 0bin1) => final_Ex[0bin011110001101]=0bin00011000);
-ASSERT((X[0bin011110001101] & X[0bin011110111010] = 0bin0) => final_Ex[0bin011110001101]=0bin00000000);
-ASSERT((X[0bin011110001111] & X[0bin011110111100] = 0bin1) => final_Ex[0bin011110001111]=0bin00001111);
-ASSERT((X[0bin011110001111] & X[0bin011110111100] = 0bin0) => final_Ex[0bin011110001111]=0bin00000000);
-ASSERT((X[0bin011110010011] & X[0bin011111000000] = 0bin1) => final_Ex[0bin011110010011]=0bin00011000);
-ASSERT((X[0bin011110010011] & X[0bin011111000000] = 0bin0) => final_Ex[0bin011110010011]=0bin00000000);
-ASSERT((X[0bin011110010111] & X[0bin011111000100] = 0bin1) => final_Ex[0bin011110010111]=0bin00001111);
-ASSERT((X[0bin011110010111] & X[0bin011111000100] = 0bin0) => final_Ex[0bin011110010111]=0bin00000000);
-ASSERT((X[0bin011110011100] & X[0bin011111001001] = 0bin1) => final_Ex[0bin011110011100]=0bin00001101);
-ASSERT((X[0bin011110011100] & X[0bin011111001001] = 0bin0) => final_Ex[0bin011110011100]=0bin00000000);
-ASSERT((X[0bin011110011110] & X[0bin011111001011] = 0bin1) => final_Ex[0bin011110011110]=0bin00011000);
-ASSERT((X[0bin011110011110] & X[0bin011111001011] = 0bin0) => final_Ex[0bin011110011110]=0bin00000000);
-ASSERT((X[0bin011110100010] & X[0bin011111001111] = 0bin1) => final_Ex[0bin011110100010]=0bin00011000);
-ASSERT((X[0bin011110100010] & X[0bin011111001111] = 0bin0) => final_Ex[0bin011110100010]=0bin00000000);
-ASSERT((X[0bin011110100101] & X[0bin011111010010] = 0bin1) => final_Ex[0bin011110100101]=0bin00011000);
-ASSERT((X[0bin011110100101] & X[0bin011111010010] = 0bin0) => final_Ex[0bin011110100101]=0bin00000000);
-ASSERT((X[0bin011110101000] & X[0bin011111010101] = 0bin1) => final_Ex[0bin011110101000]=0bin00011000);
-ASSERT((X[0bin011110101000] & X[0bin011111010101] = 0bin0) => final_Ex[0bin011110101000]=0bin00000000);
-ASSERT((X[0bin011110101011] & X[0bin011111011000] = 0bin1) => final_Ex[0bin011110101011]=0bin00001101);
-ASSERT((X[0bin011110101011] & X[0bin011111011000] = 0bin0) => final_Ex[0bin011110101011]=0bin00000000);
-ASSERT((X[0bin011110101110] & X[0bin011111011011] = 0bin1) => final_Ex[0bin011110101110]=0bin00000101);
-ASSERT((X[0bin011110101110] & X[0bin011111011011] = 0bin0) => final_Ex[0bin011110101110]=0bin00000000);
-ASSERT((X[0bin011110110000] & X[0bin011111011101] = 0bin1) => final_Ex[0bin011110110000]=0bin00001111);
-ASSERT((X[0bin011110110000] & X[0bin011111011101] = 0bin0) => final_Ex[0bin011110110000]=0bin00000000);
-ASSERT(X[0bin011110110110]=0bin0);
-ASSERT(X[0bin011110110111]=0bin0);
-ASSERT((X[0bin011110111001] & X[0bin011111100110] = 0bin1) => final_Ex[0bin011110111001]=0bin00011000);
-ASSERT((X[0bin011110111001] & X[0bin011111100110] = 0bin0) => final_Ex[0bin011110111001]=0bin00000000);
-ASSERT((X[0bin011110111100] & X[0bin011111101001] = 0bin1) => final_Ex[0bin011110111100]=0bin00001111);
-ASSERT((X[0bin011110111100] & X[0bin011111101001] = 0bin0) => final_Ex[0bin011110111100]=0bin00000000);
-ASSERT((X[0bin011110111111] & X[0bin011111101100] = 0bin1) => final_Ex[0bin011110111111]=0bin00011000);
-ASSERT((X[0bin011110111111] & X[0bin011111101100] = 0bin0) => final_Ex[0bin011110111111]=0bin00000000);
-ASSERT((X[0bin011111000011] & X[0bin011111110000] = 0bin1) => final_Ex[0bin011111000011]=0bin00000101);
-ASSERT((X[0bin011111000011] & X[0bin011111110000] = 0bin0) => final_Ex[0bin011111000011]=0bin00000000);
-ASSERT((X[0bin011111001001] & X[0bin011111110110] = 0bin1) => final_Ex[0bin011111001001]=0bin00011000);
-ASSERT((X[0bin011111001001] & X[0bin011111110110] = 0bin0) => final_Ex[0bin011111001001]=0bin00000000);
-ASSERT((X[0bin011111001011] & X[0bin011111111000] = 0bin1) => final_Ex[0bin011111001011]=0bin00001101);
-ASSERT((X[0bin011111001011] & X[0bin011111111000] = 0bin0) => final_Ex[0bin011111001011]=0bin00000000);
-ASSERT((X[0bin011111001110] & X[0bin011111111011] = 0bin1) => final_Ex[0bin011111001110]=0bin00001111);
-ASSERT((X[0bin011111001110] & X[0bin011111111011] = 0bin0) => final_Ex[0bin011111001110]=0bin00000000);
-ASSERT((X[0bin011111010001] & X[0bin011111111110] = 0bin1) => final_Ex[0bin011111010001]=0bin00001111);
-ASSERT((X[0bin011111010001] & X[0bin011111111110] = 0bin0) => final_Ex[0bin011111010001]=0bin00000000);
-ASSERT((X[0bin011111010101] & X[0bin100000000010] = 0bin1) => final_Ex[0bin011111010101]=0bin00011000);
-ASSERT((X[0bin011111010101] & X[0bin100000000010] = 0bin0) => final_Ex[0bin011111010101]=0bin00000000);
-ASSERT((X[0bin011111010111] & X[0bin100000000100] = 0bin1) => final_Ex[0bin011111010111]=0bin00011000);
-ASSERT((X[0bin011111010111] & X[0bin100000000100] = 0bin0) => final_Ex[0bin011111010111]=0bin00000000);
-ASSERT((X[0bin011111011010] & X[0bin100000000111] = 0bin1) => final_Ex[0bin011111011010]=0bin00000101);
-ASSERT((X[0bin011111011010] & X[0bin100000000111] = 0bin0) => final_Ex[0bin011111011010]=0bin00000000);
-ASSERT((X[0bin011111011101] & X[0bin100000001010] = 0bin1) => final_Ex[0bin011111011101]=0bin00000101);
-ASSERT((X[0bin011111011101] & X[0bin100000001010] = 0bin0) => final_Ex[0bin011111011101]=0bin00000000);
-ASSERT((X[0bin011111011111] & X[0bin100000001100] = 0bin1) => final_Ex[0bin011111011111]=0bin00011000);
-ASSERT((X[0bin011111011111] & X[0bin100000001100] = 0bin0) => final_Ex[0bin011111011111]=0bin00000000);
-ASSERT(X[0bin011111100101]=0bin0);
-ASSERT(X[0bin011111100110]=0bin0);
-ASSERT((X[0bin011111101001] & X[0bin100000010110] = 0bin1) => final_Ex[0bin011111101001]=0bin00100001);
-ASSERT((X[0bin011111101001] & X[0bin100000010110] = 0bin0) => final_Ex[0bin011111101001]=0bin00000000);
-ASSERT((X[0bin011111101111] & X[0bin100000011100] = 0bin1) => final_Ex[0bin011111101111]=0bin00100001);
-ASSERT((X[0bin011111101111] & X[0bin100000011100] = 0bin0) => final_Ex[0bin011111101111]=0bin00000000);
-ASSERT((X[0bin011111111000] & X[0bin100000100101] = 0bin1) => final_Ex[0bin011111111000]=0bin00010101);
-ASSERT((X[0bin011111111000] & X[0bin100000100101] = 0bin0) => final_Ex[0bin011111111000]=0bin00000000);
-ASSERT((X[0bin011111111010] & X[0bin100000100111] = 0bin1) => final_Ex[0bin011111111010]=0bin00100001);
-ASSERT((X[0bin011111111010] & X[0bin100000100111] = 0bin0) => final_Ex[0bin011111111010]=0bin00000000);
-ASSERT((X[0bin011111111110] & X[0bin100000101011] = 0bin1) => final_Ex[0bin011111111110]=0bin00100001);
-ASSERT((X[0bin011111111110] & X[0bin100000101011] = 0bin0) => final_Ex[0bin011111111110]=0bin00000000);
-ASSERT((X[0bin100000000001] & X[0bin100000101110] = 0bin1) => final_Ex[0bin100000000001]=0bin00100001);
-ASSERT((X[0bin100000000001] & X[0bin100000101110] = 0bin0) => final_Ex[0bin100000000001]=0bin00000000);
-ASSERT((X[0bin100000000100] & X[0bin100000110001] = 0bin1) => final_Ex[0bin100000000100]=0bin00100001);
-ASSERT((X[0bin100000000100] & X[0bin100000110001] = 0bin0) => final_Ex[0bin100000000100]=0bin00000000);
-ASSERT((X[0bin100000000111] & X[0bin100000110100] = 0bin1) => final_Ex[0bin100000000111]=0bin00010101);
-ASSERT((X[0bin100000000111] & X[0bin100000110100] = 0bin0) => final_Ex[0bin100000000111]=0bin00000000);
-ASSERT((X[0bin100000010011] & X[0bin100001000000] = 0bin1) => final_Ex[0bin100000010011]=0bin00010101);
-ASSERT((X[0bin100000010011] & X[0bin100001000000] = 0bin0) => final_Ex[0bin100000010011]=0bin00000000);
-ASSERT(X[0bin100000010100]=0bin0);
-ASSERT(X[0bin100000010101]=0bin0);
-ASSERT(X[0bin100001000011]=0bin0);
-%%%%%%%%%% (2) %%%%%%%%%%
-ASSERT(Y[0bin000000000000]=0bin0);
-ASSERT(Y[0bin000000000001]=0bin0);
-ASSERT((Y[0bin000000000111] & Y[0bin000000110100] = 0bin1) => final_Ey[0bin000000000111]=0bin00010111);
-ASSERT((Y[0bin000000000111] & Y[0bin000000110100] = 0bin0) => final_Ey[0bin000000000111]=0bin00000000);
-ASSERT((Y[0bin000000010000] & Y[0bin000000111101] = 0bin1) => final_Ey[0bin000000010000]=0bin00001110);
-ASSERT((Y[0bin000000010000] & Y[0bin000000111101] = 0bin0) => final_Ey[0bin000000010000]=0bin00000000);
-ASSERT((Y[0bin000000010010] & Y[0bin000000111111] = 0bin1) => final_Ey[0bin000000010010]=0bin00010111);
-ASSERT((Y[0bin000000010010] & Y[0bin000000111111] = 0bin0) => final_Ey[0bin000000010010]=0bin00000000);
-ASSERT((Y[0bin000000010110] & Y[0bin000001000011] = 0bin1) => final_Ey[0bin000000010110]=0bin00010111);
-ASSERT((Y[0bin000000010110] & Y[0bin000001000011] = 0bin0) => final_Ey[0bin000000010110]=0bin00000000);
-ASSERT((Y[0bin000000011001] & Y[0bin000001000110] = 0bin1) => final_Ey[0bin000000011001]=0bin00010111);
-ASSERT((Y[0bin000000011001] & Y[0bin000001000110] = 0bin0) => final_Ey[0bin000000011001]=0bin00000000);
-ASSERT((Y[0bin000000011100] & Y[0bin000001001001] = 0bin1) => final_Ey[0bin000000011100]=0bin00010111);
-ASSERT((Y[0bin000000011100] & Y[0bin000001001001] = 0bin0) => final_Ey[0bin000000011100]=0bin00000000);
-ASSERT((Y[0bin000000011111] & Y[0bin000001001100] = 0bin1) => final_Ey[0bin000000011111]=0bin00001110);
-ASSERT((Y[0bin000000011111] & Y[0bin000001001100] = 0bin0) => final_Ey[0bin000000011111]=0bin00000000);
-ASSERT((Y[0bin000000101011] & Y[0bin000001011000] = 0bin1) => final_Ey[0bin000000101011]=0bin00001110);
-ASSERT((Y[0bin000000101011] & Y[0bin000001011000] = 0bin0) => final_Ey[0bin000000101011]=0bin00000000);
-ASSERT((Y[0bin000000101101] & Y[0bin000001011010] = 0bin1) => final_Ey[0bin000000101101]=0bin00010111);
-ASSERT((Y[0bin000000101101] & Y[0bin000001011010] = 0bin0) => final_Ey[0bin000000101101]=0bin00000000);
-ASSERT(Y[0bin000000101111]=0bin0);
-ASSERT(Y[0bin000000110000]=0bin0);
-ASSERT((Y[0bin000000111111] & Y[0bin000001101100] = 0bin1) => final_Ey[0bin000000111111]=0bin00001110);
-ASSERT((Y[0bin000000111111] & Y[0bin000001101100] = 0bin0) => final_Ey[0bin000000111111]=0bin00000000);
-ASSERT((Y[0bin000001011010] & Y[0bin000010000111] = 0bin1) => final_Ey[0bin000001011010]=0bin00001110);
-ASSERT((Y[0bin000001011010] & Y[0bin000010000111] = 0bin0) => final_Ey[0bin000001011010]=0bin00000000);
-ASSERT(Y[0bin000001011110]=0bin0);
-ASSERT(Y[0bin000001011111]=0bin0);
-ASSERT((Y[0bin000001101100] & Y[0bin000010011001] = 0bin1) => final_Ey[0bin000001101100]=0bin00001110);
-ASSERT((Y[0bin000001101100] & Y[0bin000010011001] = 0bin0) => final_Ey[0bin000001101100]=0bin00000000);
-ASSERT((Y[0bin000001111011] & Y[0bin000010101000] = 0bin1) => final_Ey[0bin000001111011]=0bin00001110);
-ASSERT((Y[0bin000001111011] & Y[0bin000010101000] = 0bin0) => final_Ey[0bin000001111011]=0bin00000000);
-ASSERT((Y[0bin000010000111] & Y[0bin000010110100] = 0bin1) => final_Ey[0bin000010000111]=0bin00001110);
-ASSERT((Y[0bin000010000111] & Y[0bin000010110100] = 0bin0) => final_Ey[0bin000010000111]=0bin00000000);
-ASSERT(Y[0bin000010001101]=0bin0);
-ASSERT(Y[0bin000010001110]=0bin0);
-ASSERT((Y[0bin000010010000] & Y[0bin000010111101] = 0bin1) => final_Ey[0bin000010010000]=0bin00010000);
-ASSERT((Y[0bin000010010000] & Y[0bin000010111101] = 0bin0) => final_Ey[0bin000010010000]=0bin00000000);
-ASSERT((Y[0bin000010101000] & Y[0bin000011010101] = 0bin1) => final_Ey[0bin000010101000]=0bin00010000);
-ASSERT((Y[0bin000010101000] & Y[0bin000011010101] = 0bin0) => final_Ey[0bin000010101000]=0bin00000000);
-ASSERT((Y[0bin000010110000] & Y[0bin000011011101] = 0bin1) => final_Ey[0bin000010110000]=0bin00010000);
-ASSERT((Y[0bin000010110000] & Y[0bin000011011101] = 0bin0) => final_Ey[0bin000010110000]=0bin00000000);
-ASSERT((Y[0bin000010110011] & Y[0bin000011100000] = 0bin1) => final_Ey[0bin000010110011]=0bin00010000);
-ASSERT((Y[0bin000010110011] & Y[0bin000011100000] = 0bin0) => final_Ey[0bin000010110011]=0bin00000000);
-ASSERT((Y[0bin000010110100] & Y[0bin000011100001] = 0bin1) => final_Ey[0bin000010110100]=0bin00010000);
-ASSERT((Y[0bin000010110100] & Y[0bin000011100001] = 0bin0) => final_Ey[0bin000010110100]=0bin00000000);
-ASSERT(Y[0bin000010111100]=0bin0);
-ASSERT(Y[0bin000010111101]=0bin0);
-ASSERT((Y[0bin000011000111] & Y[0bin000011110100] = 0bin1) => final_Ey[0bin000011000111]=0bin00010111);
-ASSERT((Y[0bin000011000111] & Y[0bin000011110100] = 0bin0) => final_Ey[0bin000011000111]=0bin00000000);
-ASSERT((Y[0bin000011001001] & Y[0bin000011110110] = 0bin1) => final_Ey[0bin000011001001]=0bin00001110);
-ASSERT((Y[0bin000011001001] & Y[0bin000011110110] = 0bin0) => final_Ey[0bin000011001001]=0bin00000000);
-ASSERT((Y[0bin000011010011] & Y[0bin000100000000] = 0bin1) => final_Ey[0bin000011010011]=0bin00010111);
-ASSERT((Y[0bin000011010011] & Y[0bin000100000000] = 0bin0) => final_Ey[0bin000011010011]=0bin00000000);
-ASSERT((Y[0bin000011010101] & Y[0bin000100000010] = 0bin1) => final_Ey[0bin000011010101]=0bin00010111);
-ASSERT((Y[0bin000011010101] & Y[0bin000100000010] = 0bin0) => final_Ey[0bin000011010101]=0bin00000000);
-ASSERT((Y[0bin000011011101] & Y[0bin000100001010] = 0bin1) => final_Ey[0bin000011011101]=0bin00010111);
-ASSERT((Y[0bin000011011101] & Y[0bin000100001010] = 0bin0) => final_Ey[0bin000011011101]=0bin00000000);
-ASSERT((Y[0bin000011100100] & Y[0bin000100010001] = 0bin1) => final_Ey[0bin000011100100]=0bin00001110);
-ASSERT((Y[0bin000011100100] & Y[0bin000100010001] = 0bin0) => final_Ey[0bin000011100100]=0bin00000000);
-ASSERT((Y[0bin000011101010] & Y[0bin000100010111] = 0bin1) => final_Ey[0bin000011101010]=0bin00010111);
-ASSERT((Y[0bin000011101010] & Y[0bin000100010111] = 0bin0) => final_Ey[0bin000011101010]=0bin00000000);
-ASSERT(Y[0bin000011101011]=0bin0);
-ASSERT(Y[0bin000011101100]=0bin0);
-ASSERT((Y[0bin000011101110] & Y[0bin000100011011] = 0bin1) => final_Ey[0bin000011101110]=0bin00010001);
-ASSERT((Y[0bin000011101110] & Y[0bin000100011011] = 0bin0) => final_Ey[0bin000011101110]=0bin00000000);
-ASSERT((Y[0bin000011110010] & Y[0bin000100011111] = 0bin1) => final_Ey[0bin000011110010]=0bin00010001);
-ASSERT((Y[0bin000011110010] & Y[0bin000100011111] = 0bin0) => final_Ey[0bin000011110010]=0bin00000000);
-ASSERT((Y[0bin000011110011] & Y[0bin000100100000] = 0bin1) => final_Ey[0bin000011110011]=0bin00010001);
-ASSERT((Y[0bin000011110011] & Y[0bin000100100000] = 0bin0) => final_Ey[0bin000011110011]=0bin00000000);
-ASSERT((Y[0bin000011110100] & Y[0bin000100100001] = 0bin1) => final_Ey[0bin000011110100]=0bin00010111);
-ASSERT((Y[0bin000011110100] & Y[0bin000100100001] = 0bin0) => final_Ey[0bin000011110100]=0bin00000000);
-ASSERT((Y[0bin000011111001] & Y[0bin000100100110] = 0bin1) => final_Ey[0bin000011111001]=0bin00010111);
-ASSERT((Y[0bin000011111001] & Y[0bin000100100110] = 0bin0) => final_Ey[0bin000011111001]=0bin00000000);
-ASSERT((Y[0bin000100000000] & Y[0bin000100101101] = 0bin1) => final_Ey[0bin000100000000]=0bin00010111);
-ASSERT((Y[0bin000100000000] & Y[0bin000100101101] = 0bin0) => final_Ey[0bin000100000000]=0bin00000000);
-ASSERT((Y[0bin000100010101] & Y[0bin000101000010] = 0bin1) => final_Ey[0bin000100010101]=0bin00010111);
-ASSERT((Y[0bin000100010101] & Y[0bin000101000010] = 0bin0) => final_Ey[0bin000100010101]=0bin00000000);
-ASSERT(Y[0bin000100011010]=0bin0);
-ASSERT(Y[0bin000100011011]=0bin0);
-ASSERT((Y[0bin000100100100] & Y[0bin000101010001] = 0bin1) => final_Ey[0bin000100100100]=0bin00001110);
-ASSERT((Y[0bin000100100100] & Y[0bin000101010001] = 0bin0) => final_Ey[0bin000100100100]=0bin00000000);
-ASSERT((Y[0bin000100100110] & Y[0bin000101010011] = 0bin1) => final_Ey[0bin000100100110]=0bin00010111);
-ASSERT((Y[0bin000100100110] & Y[0bin000101010011] = 0bin0) => final_Ey[0bin000100100110]=0bin00000000);
-ASSERT((Y[0bin000100101010] & Y[0bin000101010111] = 0bin1) => final_Ey[0bin000100101010]=0bin00010111);
-ASSERT((Y[0bin000100101010] & Y[0bin000101010111] = 0bin0) => final_Ey[0bin000100101010]=0bin00000000);
-ASSERT((Y[0bin000100101101] & Y[0bin000101011010] = 0bin1) => final_Ey[0bin000100101101]=0bin00010111);
-ASSERT((Y[0bin000100101101] & Y[0bin000101011010] = 0bin0) => final_Ey[0bin000100101101]=0bin00000000);
-ASSERT((Y[0bin000100110000] & Y[0bin000101011101] = 0bin1) => final_Ey[0bin000100110000]=0bin00010111);
-ASSERT((Y[0bin000100110000] & Y[0bin000101011101] = 0bin0) => final_Ey[0bin000100110000]=0bin00000000);
-ASSERT((Y[0bin000100110011] & Y[0bin000101100000] = 0bin1) => final_Ey[0bin000100110011]=0bin00001110);
-ASSERT((Y[0bin000100110011] & Y[0bin000101100000] = 0bin0) => final_Ey[0bin000100110011]=0bin00000000);
-ASSERT((Y[0bin000100111111] & Y[0bin000101101100] = 0bin1) => final_Ey[0bin000100111111]=0bin00001110);
-ASSERT((Y[0bin000100111111] & Y[0bin000101101100] = 0bin0) => final_Ey[0bin000100111111]=0bin00000000);
-ASSERT((Y[0bin000101000001] & Y[0bin000101101110] = 0bin1) => final_Ey[0bin000101000001]=0bin00010111);
-ASSERT((Y[0bin000101000001] & Y[0bin000101101110] = 0bin0) => final_Ey[0bin000101000001]=0bin00000000);
-ASSERT((Y[0bin000101001000] & Y[0bin000101110101] = 0bin1) => final_Ey[0bin000101001000]=0bin00001110);
-ASSERT((Y[0bin000101001000] & Y[0bin000101110101] = 0bin0) => final_Ey[0bin000101001000]=0bin00000000);
-ASSERT(Y[0bin000101001001]=0bin0);
-ASSERT(Y[0bin000101001010]=0bin0);
-ASSERT((Y[0bin000101010111] & Y[0bin000110000100] = 0bin1) => final_Ey[0bin000101010111]=0bin00001001);
-ASSERT((Y[0bin000101010111] & Y[0bin000110000100] = 0bin0) => final_Ey[0bin000101010111]=0bin00000000);
-ASSERT((Y[0bin000101011010] & Y[0bin000110000111] = 0bin1) => final_Ey[0bin000101011010]=0bin00001001);
-ASSERT((Y[0bin000101011010] & Y[0bin000110000111] = 0bin0) => final_Ey[0bin000101011010]=0bin00000000);
-ASSERT((Y[0bin000101100000] & Y[0bin000110001101] = 0bin1) => final_Ey[0bin000101100000]=0bin00001110);
-ASSERT((Y[0bin000101100000] & Y[0bin000110001101] = 0bin0) => final_Ey[0bin000101100000]=0bin00000000);
-ASSERT((Y[0bin000101101000] & Y[0bin000110010101] = 0bin1) => final_Ey[0bin000101101000]=0bin00001110);
-ASSERT((Y[0bin000101101000] & Y[0bin000110010101] = 0bin0) => final_Ey[0bin000101101000]=0bin00000000);
-ASSERT((Y[0bin000101101010] & Y[0bin000110010111] = 0bin1) => final_Ey[0bin000101101010]=0bin00001001);
-ASSERT((Y[0bin000101101010] & Y[0bin000110010111] = 0bin0) => final_Ey[0bin000101101010]=0bin00000000);
-ASSERT((Y[0bin000101101011] & Y[0bin000110011000] = 0bin1) => final_Ey[0bin000101101011]=0bin00001110);
-ASSERT((Y[0bin000101101011] & Y[0bin000110011000] = 0bin0) => final_Ey[0bin000101101011]=0bin00000000);
-ASSERT((Y[0bin000101101100] & Y[0bin000110011001] = 0bin1) => final_Ey[0bin000101101100]=0bin00001110);
-ASSERT((Y[0bin000101101100] & Y[0bin000110011001] = 0bin0) => final_Ey[0bin000101101100]=0bin00000000);
-ASSERT(Y[0bin000101111000]=0bin0);
-ASSERT(Y[0bin000101111001]=0bin0);
-ASSERT((Y[0bin000110000001] & Y[0bin000110101110] = 0bin1) => final_Ey[0bin000110000001]=0bin00000110);
-ASSERT((Y[0bin000110000001] & Y[0bin000110101110] = 0bin0) => final_Ey[0bin000110000001]=0bin00000000);
-ASSERT((Y[0bin000110010000] & Y[0bin000110111101] = 0bin1) => final_Ey[0bin000110010000]=0bin00000100);
-ASSERT((Y[0bin000110010000] & Y[0bin000110111101] = 0bin0) => final_Ey[0bin000110010000]=0bin00000000);
-ASSERT((Y[0bin000110010011] & Y[0bin000111000000] = 0bin1) => final_Ey[0bin000110010011]=0bin00000100);
-ASSERT((Y[0bin000110010011] & Y[0bin000111000000] = 0bin0) => final_Ey[0bin000110010011]=0bin00000000);
-ASSERT((Y[0bin000110011100] & Y[0bin000111001001] = 0bin1) => final_Ey[0bin000110011100]=0bin00000110);
-ASSERT((Y[0bin000110011100] & Y[0bin000111001001] = 0bin0) => final_Ey[0bin000110011100]=0bin00000000);
-ASSERT(Y[0bin000110100111]=0bin0);
-ASSERT(Y[0bin000110101000]=0bin0);
-ASSERT(Y[0bin000111010110]=0bin0);
-ASSERT(Y[0bin000111010111]=0bin0);
-ASSERT((Y[0bin000111011100] & Y[0bin001000001001] = 0bin1) => final_Ey[0bin000111011100]=0bin00001110);
-ASSERT((Y[0bin000111011100] & Y[0bin001000001001] = 0bin0) => final_Ey[0bin000111011100]=0bin00000000);
-ASSERT((Y[0bin000111101011] & Y[0bin001000011000] = 0bin1) => final_Ey[0bin000111101011]=0bin00001110);
-ASSERT((Y[0bin000111101011] & Y[0bin001000011000] = 0bin0) => final_Ey[0bin000111101011]=0bin00000000);
-ASSERT((Y[0bin000111110111] & Y[0bin001000100100] = 0bin1) => final_Ey[0bin000111110111]=0bin00001110);
-ASSERT((Y[0bin000111110111] & Y[0bin001000100100] = 0bin0) => final_Ey[0bin000111110111]=0bin00000000);
-ASSERT((Y[0bin001000000000] & Y[0bin001000101101] = 0bin1) => final_Ey[0bin001000000000]=0bin00001110);
-ASSERT((Y[0bin001000000000] & Y[0bin001000101101] = 0bin0) => final_Ey[0bin001000000000]=0bin00000000);
-ASSERT(Y[0bin001000000101]=0bin0);
-ASSERT(Y[0bin001000000110]=0bin0);
-ASSERT((Y[0bin001000001111] & Y[0bin001000111100] = 0bin1) => final_Ey[0bin001000001111]=0bin00001001);
-ASSERT((Y[0bin001000001111] & Y[0bin001000111100] = 0bin0) => final_Ey[0bin001000001111]=0bin00000000);
-ASSERT((Y[0bin001000010010] & Y[0bin001000111111] = 0bin1) => final_Ey[0bin001000010010]=0bin00001001);
-ASSERT((Y[0bin001000010010] & Y[0bin001000111111] = 0bin0) => final_Ey[0bin001000010010]=0bin00000000);
-ASSERT((Y[0bin001000011000] & Y[0bin001001000101] = 0bin1) => final_Ey[0bin001000011000]=0bin00001110);
-ASSERT((Y[0bin001000011000] & Y[0bin001001000101] = 0bin0) => final_Ey[0bin001000011000]=0bin00000000);
-ASSERT((Y[0bin001000100000] & Y[0bin001001001101] = 0bin1) => final_Ey[0bin001000100000]=0bin00001110);
-ASSERT((Y[0bin001000100000] & Y[0bin001001001101] = 0bin0) => final_Ey[0bin001000100000]=0bin00000000);
-ASSERT((Y[0bin001000100010] & Y[0bin001001001111] = 0bin1) => final_Ey[0bin001000100010]=0bin00001001);
-ASSERT((Y[0bin001000100010] & Y[0bin001001001111] = 0bin0) => final_Ey[0bin001000100010]=0bin00000000);
-ASSERT((Y[0bin001000100011] & Y[0bin001001010000] = 0bin1) => final_Ey[0bin001000100011]=0bin00001110);
-ASSERT((Y[0bin001000100011] & Y[0bin001001010000] = 0bin0) => final_Ey[0bin001000100011]=0bin00000000);
-ASSERT((Y[0bin001000100100] & Y[0bin001001010001] = 0bin1) => final_Ey[0bin001000100100]=0bin00001110);
-ASSERT((Y[0bin001000100100] & Y[0bin001001010001] = 0bin0) => final_Ey[0bin001000100100]=0bin00000000);
-ASSERT((Y[0bin001000101110] & Y[0bin001001011011] = 0bin1) => final_Ey[0bin001000101110]=0bin00001110);
-ASSERT((Y[0bin001000101110] & Y[0bin001001011011] = 0bin0) => final_Ey[0bin001000101110]=0bin00000000);
-ASSERT(Y[0bin001000110100]=0bin0);
-ASSERT(Y[0bin001000110101]=0bin0);
-ASSERT((Y[0bin001001000110] & Y[0bin001001110011] = 0bin1) => final_Ey[0bin001001000110]=0bin00001110);
-ASSERT((Y[0bin001001000110] & Y[0bin001001110011] = 0bin0) => final_Ey[0bin001001000110]=0bin00000000);
-ASSERT((Y[0bin001001001110] & Y[0bin001001111011] = 0bin1) => final_Ey[0bin001001001110]=0bin00001110);
-ASSERT((Y[0bin001001001110] & Y[0bin001001111011] = 0bin0) => final_Ey[0bin001001001110]=0bin00000000);
-ASSERT((Y[0bin001001001111] & Y[0bin001001111100] = 0bin1) => final_Ey[0bin001001001111]=0bin00001001);
-ASSERT((Y[0bin001001001111] & Y[0bin001001111100] = 0bin0) => final_Ey[0bin001001001111]=0bin00000000);
-ASSERT((Y[0bin001001010001] & Y[0bin001001111110] = 0bin1) => final_Ey[0bin001001010001]=0bin00001110);
-ASSERT((Y[0bin001001010001] & Y[0bin001001111110] = 0bin0) => final_Ey[0bin001001010001]=0bin00000000);
-ASSERT((Y[0bin001001010010] & Y[0bin001001111111] = 0bin1) => final_Ey[0bin001001010010]=0bin00001110);
-ASSERT((Y[0bin001001010010] & Y[0bin001001111111] = 0bin0) => final_Ey[0bin001001010010]=0bin00000000);
-ASSERT((Y[0bin001001011100] & Y[0bin001010001001] = 0bin1) => final_Ey[0bin001001011100]=0bin00010000);
-ASSERT((Y[0bin001001011100] & Y[0bin001010001001] = 0bin0) => final_Ey[0bin001001011100]=0bin00000000);
-ASSERT(Y[0bin001001100011]=0bin0);
-ASSERT(Y[0bin001001100100]=0bin0);
-ASSERT((Y[0bin001001110100] & Y[0bin001010100001] = 0bin1) => final_Ey[0bin001001110100]=0bin00010000);
-ASSERT((Y[0bin001001110100] & Y[0bin001010100001] = 0bin0) => final_Ey[0bin001001110100]=0bin00000000);
-ASSERT((Y[0bin001001111100] & Y[0bin001010101001] = 0bin1) => final_Ey[0bin001001111100]=0bin00010000);
-ASSERT((Y[0bin001001111100] & Y[0bin001010101001] = 0bin0) => final_Ey[0bin001001111100]=0bin00000000);
-ASSERT((Y[0bin001001111111] & Y[0bin001010101100] = 0bin1) => final_Ey[0bin001001111111]=0bin00010000);
-ASSERT((Y[0bin001001111111] & Y[0bin001010101100] = 0bin0) => final_Ey[0bin001001111111]=0bin00000000);
-ASSERT((Y[0bin001010000000] & Y[0bin001010101101] = 0bin1) => final_Ey[0bin001010000000]=0bin00010000);
-ASSERT((Y[0bin001010000000] & Y[0bin001010101101] = 0bin0) => final_Ey[0bin001010000000]=0bin00000000);
-ASSERT((Y[0bin001010001001] & Y[0bin001010110110] = 0bin1) => final_Ey[0bin001010001001]=0bin00010111);
-ASSERT((Y[0bin001010001001] & Y[0bin001010110110] = 0bin0) => final_Ey[0bin001010001001]=0bin00000000);
-ASSERT(Y[0bin001010010010]=0bin0);
-ASSERT(Y[0bin001010010011]=0bin0);
-ASSERT((Y[0bin001010010101] & Y[0bin001011000010] = 0bin1) => final_Ey[0bin001010010101]=0bin00001110);
-ASSERT((Y[0bin001010010101] & Y[0bin001011000010] = 0bin0) => final_Ey[0bin001010010101]=0bin00000000);
-ASSERT((Y[0bin001010011111] & Y[0bin001011001100] = 0bin1) => final_Ey[0bin001010011111]=0bin00010111);
-ASSERT((Y[0bin001010011111] & Y[0bin001011001100] = 0bin0) => final_Ey[0bin001010011111]=0bin00000000);
-ASSERT((Y[0bin001010100001] & Y[0bin001011001110] = 0bin1) => final_Ey[0bin001010100001]=0bin00010111);
-ASSERT((Y[0bin001010100001] & Y[0bin001011001110] = 0bin0) => final_Ey[0bin001010100001]=0bin00000000);
-ASSERT((Y[0bin001010101001] & Y[0bin001011010110] = 0bin1) => final_Ey[0bin001010101001]=0bin00010111);
-ASSERT((Y[0bin001010101001] & Y[0bin001011010110] = 0bin0) => final_Ey[0bin001010101001]=0bin00000000);
-ASSERT((Y[0bin001010110000] & Y[0bin001011011101] = 0bin1) => final_Ey[0bin001010110000]=0bin00001110);
-ASSERT((Y[0bin001010110000] & Y[0bin001011011101] = 0bin0) => final_Ey[0bin001010110000]=0bin00000000);
-ASSERT((Y[0bin001010110011] & Y[0bin001011100000] = 0bin1) => final_Ey[0bin001010110011]=0bin00010000);
-ASSERT((Y[0bin001010110011] & Y[0bin001011100000] = 0bin0) => final_Ey[0bin001010110011]=0bin00000000);
-ASSERT((Y[0bin001010110101] & Y[0bin001011100010] = 0bin1) => final_Ey[0bin001010110101]=0bin00001010);
-ASSERT((Y[0bin001010110101] & Y[0bin001011100010] = 0bin0) => final_Ey[0bin001010110101]=0bin00000000);
-ASSERT((Y[0bin001010111001] & Y[0bin001011100110] = 0bin1) => final_Ey[0bin001010111001]=0bin00010000);
-ASSERT((Y[0bin001010111001] & Y[0bin001011100110] = 0bin0) => final_Ey[0bin001010111001]=0bin00000000);
-ASSERT((Y[0bin001010111101] & Y[0bin001011101010] = 0bin1) => final_Ey[0bin001010111101]=0bin00001010);
-ASSERT((Y[0bin001010111101] & Y[0bin001011101010] = 0bin0) => final_Ey[0bin001010111101]=0bin00000000);
-ASSERT(Y[0bin001011000001]=0bin0);
-ASSERT(Y[0bin001011000010]=0bin0);
-ASSERT((Y[0bin001011000100] & Y[0bin001011110001] = 0bin1) => final_Ey[0bin001011000100]=0bin00010000);
-ASSERT((Y[0bin001011000100] & Y[0bin001011110001] = 0bin0) => final_Ey[0bin001011000100]=0bin00000000);
-ASSERT((Y[0bin001011001000] & Y[0bin001011110101] = 0bin1) => final_Ey[0bin001011001000]=0bin00010000);
-ASSERT((Y[0bin001011001000] & Y[0bin001011110101] = 0bin0) => final_Ey[0bin001011001000]=0bin00000000);
-ASSERT((Y[0bin001011001011] & Y[0bin001011111000] = 0bin1) => final_Ey[0bin001011001011]=0bin00010000);
-ASSERT((Y[0bin001011001011] & Y[0bin001011111000] = 0bin0) => final_Ey[0bin001011001011]=0bin00000000);
-ASSERT((Y[0bin001011001110] & Y[0bin001011111011] = 0bin1) => final_Ey[0bin001011001110]=0bin00010000);
-ASSERT((Y[0bin001011001110] & Y[0bin001011111011] = 0bin0) => final_Ey[0bin001011001110]=0bin00000000);
-ASSERT((Y[0bin001011010001] & Y[0bin001011111110] = 0bin1) => final_Ey[0bin001011010001]=0bin00001001);
-ASSERT((Y[0bin001011010001] & Y[0bin001011111110] = 0bin0) => final_Ey[0bin001011010001]=0bin00000000);
-ASSERT((Y[0bin001011010100] & Y[0bin001100000001] = 0bin1) => final_Ey[0bin001011010100]=0bin00000011);
-ASSERT((Y[0bin001011010100] & Y[0bin001100000001] = 0bin0) => final_Ey[0bin001011010100]=0bin00000000);
-ASSERT((Y[0bin001011010110] & Y[0bin001100000011] = 0bin1) => final_Ey[0bin001011010110]=0bin00001010);
-ASSERT((Y[0bin001011010110] & Y[0bin001100000011] = 0bin0) => final_Ey[0bin001011010110]=0bin00000000);
-ASSERT((Y[0bin001011011101] & Y[0bin001100001010] = 0bin1) => final_Ey[0bin001011011101]=0bin00001001);
-ASSERT((Y[0bin001011011101] & Y[0bin001100001010] = 0bin0) => final_Ey[0bin001011011101]=0bin00000000);
-ASSERT((Y[0bin001011011111] & Y[0bin001100001100] = 0bin1) => final_Ey[0bin001011011111]=0bin00010000);
-ASSERT((Y[0bin001011011111] & Y[0bin001100001100] = 0bin0) => final_Ey[0bin001011011111]=0bin00000000);
-ASSERT((Y[0bin001011100010] & Y[0bin001100001111] = 0bin1) => final_Ey[0bin001011100010]=0bin00001010);
-ASSERT((Y[0bin001011100010] & Y[0bin001100001111] = 0bin0) => final_Ey[0bin001011100010]=0bin00000000);
-ASSERT((Y[0bin001011100101] & Y[0bin001100010010] = 0bin1) => final_Ey[0bin001011100101]=0bin00010000);
-ASSERT((Y[0bin001011100101] & Y[0bin001100010010] = 0bin0) => final_Ey[0bin001011100101]=0bin00000000);
-ASSERT((Y[0bin001011101001] & Y[0bin001100010110] = 0bin1) => final_Ey[0bin001011101001]=0bin00000011);
-ASSERT((Y[0bin001011101001] & Y[0bin001100010110] = 0bin0) => final_Ey[0bin001011101001]=0bin00000000);
-ASSERT((Y[0bin001011101111] & Y[0bin001100011100] = 0bin1) => final_Ey[0bin001011101111]=0bin00010000);
-ASSERT((Y[0bin001011101111] & Y[0bin001100011100] = 0bin0) => final_Ey[0bin001011101111]=0bin00000000);
-ASSERT(Y[0bin001011110000]=0bin0);
-ASSERT(Y[0bin001011110001]=0bin0);
-ASSERT((Y[0bin001011110100] & Y[0bin001100100001] = 0bin1) => final_Ey[0bin001011110100]=0bin00001010);
-ASSERT((Y[0bin001011110100] & Y[0bin001100100001] = 0bin0) => final_Ey[0bin001011110100]=0bin00000000);
-ASSERT((Y[0bin001011110111] & Y[0bin001100100100] = 0bin1) => final_Ey[0bin001011110111]=0bin00001010);
-ASSERT((Y[0bin001011110111] & Y[0bin001100100100] = 0bin0) => final_Ey[0bin001011110111]=0bin00000000);
-ASSERT((Y[0bin001011111011] & Y[0bin001100101000] = 0bin1) => final_Ey[0bin001011111011]=0bin00010000);
-ASSERT((Y[0bin001011111011] & Y[0bin001100101000] = 0bin0) => final_Ey[0bin001011111011]=0bin00000000);
-ASSERT((Y[0bin001011111101] & Y[0bin001100101010] = 0bin1) => final_Ey[0bin001011111101]=0bin00010000);
-ASSERT((Y[0bin001011111101] & Y[0bin001100101010] = 0bin0) => final_Ey[0bin001011111101]=0bin00000000);
-ASSERT((Y[0bin001100000000] & Y[0bin001100101101] = 0bin1) => final_Ey[0bin001100000000]=0bin00000011);
-ASSERT((Y[0bin001100000000] & Y[0bin001100101101] = 0bin0) => final_Ey[0bin001100000000]=0bin00000000);
-ASSERT((Y[0bin001100000011] & Y[0bin001100110000] = 0bin1) => final_Ey[0bin001100000011]=0bin00000011);
-ASSERT((Y[0bin001100000011] & Y[0bin001100110000] = 0bin0) => final_Ey[0bin001100000011]=0bin00000000);
-ASSERT((Y[0bin001100000101] & Y[0bin001100110010] = 0bin1) => final_Ey[0bin001100000101]=0bin00010000);
-ASSERT((Y[0bin001100000101] & Y[0bin001100110010] = 0bin0) => final_Ey[0bin001100000101]=0bin00000000);
-ASSERT((Y[0bin001100001100] & Y[0bin001100111001] = 0bin1) => final_Ey[0bin001100001100]=0bin00001001);
-ASSERT((Y[0bin001100001100] & Y[0bin001100111001] = 0bin0) => final_Ey[0bin001100001100]=0bin00000000);
-ASSERT((Y[0bin001100001111] & Y[0bin001100111100] = 0bin1) => final_Ey[0bin001100001111]=0bin00010111);
-ASSERT((Y[0bin001100001111] & Y[0bin001100111100] = 0bin0) => final_Ey[0bin001100001111]=0bin00000000);
-ASSERT((Y[0bin001100010101] & Y[0bin001101000010] = 0bin1) => final_Ey[0bin001100010101]=0bin00010111);
-ASSERT((Y[0bin001100010101] & Y[0bin001101000010] = 0bin0) => final_Ey[0bin001100010101]=0bin00000000);
-ASSERT((Y[0bin001100011110] & Y[0bin001101001011] = 0bin1) => final_Ey[0bin001100011110]=0bin00001110);
-ASSERT((Y[0bin001100011110] & Y[0bin001101001011] = 0bin0) => final_Ey[0bin001100011110]=0bin00000000);
-ASSERT(Y[0bin001100011111]=0bin0);
-ASSERT(Y[0bin001100100000]=0bin0);
-ASSERT((Y[0bin001100100100] & Y[0bin001101010001] = 0bin1) => final_Ey[0bin001100100100]=0bin00010111);
-ASSERT((Y[0bin001100100100] & Y[0bin001101010001] = 0bin0) => final_Ey[0bin001100100100]=0bin00000000);
-ASSERT((Y[0bin001100100111] & Y[0bin001101010100] = 0bin1) => final_Ey[0bin001100100111]=0bin00010111);
-ASSERT((Y[0bin001100100111] & Y[0bin001101010100] = 0bin0) => final_Ey[0bin001100100111]=0bin00000000);
-ASSERT((Y[0bin001100101010] & Y[0bin001101010111] = 0bin1) => final_Ey[0bin001100101010]=0bin00010111);
-ASSERT((Y[0bin001100101010] & Y[0bin001101010111] = 0bin0) => final_Ey[0bin001100101010]=0bin00000000);
-ASSERT((Y[0bin001100101101] & Y[0bin001101011010] = 0bin1) => final_Ey[0bin001100101101]=0bin00001110);
-ASSERT((Y[0bin001100101101] & Y[0bin001101011010] = 0bin0) => final_Ey[0bin001100101101]=0bin00000000);
-ASSERT((Y[0bin001100111001] & Y[0bin001101100110] = 0bin1) => final_Ey[0bin001100111001]=0bin00001110);
-ASSERT((Y[0bin001100111001] & Y[0bin001101100110] = 0bin0) => final_Ey[0bin001100111001]=0bin00000000);
-ASSERT((Y[0bin001100111011] & Y[0bin001101101000] = 0bin1) => final_Ey[0bin001100111011]=0bin00010111);
-ASSERT((Y[0bin001100111011] & Y[0bin001101101000] = 0bin0) => final_Ey[0bin001100111011]=0bin00000000);
-ASSERT((Y[0bin001101000010] & Y[0bin001101101111] = 0bin1) => final_Ey[0bin001101000010]=0bin00010000);
-ASSERT((Y[0bin001101000010] & Y[0bin001101101111] = 0bin0) => final_Ey[0bin001101000010]=0bin00000000);
-ASSERT(Y[0bin001101001110]=0bin0);
-ASSERT(Y[0bin001101001111]=0bin0);
-ASSERT((Y[0bin001101011010] & Y[0bin001110000111] = 0bin1) => final_Ey[0bin001101011010]=0bin00010000);
-ASSERT((Y[0bin001101011010] & Y[0bin001110000111] = 0bin0) => final_Ey[0bin001101011010]=0bin00000000);
-ASSERT((Y[0bin001101100010] & Y[0bin001110001111] = 0bin1) => final_Ey[0bin001101100010]=0bin00010000);
-ASSERT((Y[0bin001101100010] & Y[0bin001110001111] = 0bin0) => final_Ey[0bin001101100010]=0bin00000000);
-ASSERT((Y[0bin001101100101] & Y[0bin001110010010] = 0bin1) => final_Ey[0bin001101100101]=0bin00010000);
-ASSERT((Y[0bin001101100101] & Y[0bin001110010010] = 0bin0) => final_Ey[0bin001101100101]=0bin00000000);
-ASSERT((Y[0bin001101100110] & Y[0bin001110010011] = 0bin1) => final_Ey[0bin001101100110]=0bin00010000);
-ASSERT((Y[0bin001101100110] & Y[0bin001110010011] = 0bin0) => final_Ey[0bin001101100110]=0bin00000000);
-ASSERT((Y[0bin001101111011] & Y[0bin001110101000] = 0bin1) => final_Ey[0bin001101111011]=0bin00001110);
-ASSERT((Y[0bin001101111011] & Y[0bin001110101000] = 0bin0) => final_Ey[0bin001101111011]=0bin00000000);
-ASSERT(Y[0bin001101111101]=0bin0);
-ASSERT(Y[0bin001101111110]=0bin0);
-ASSERT((Y[0bin001110010110] & Y[0bin001111000011] = 0bin1) => final_Ey[0bin001110010110]=0bin00001110);
-ASSERT((Y[0bin001110010110] & Y[0bin001111000011] = 0bin0) => final_Ey[0bin001110010110]=0bin00000000);
-ASSERT((Y[0bin001110100000] & Y[0bin001111001101] = 0bin1) => final_Ey[0bin001110100000]=0bin00001111);
-ASSERT((Y[0bin001110100000] & Y[0bin001111001101] = 0bin0) => final_Ey[0bin001110100000]=0bin00000000);
-ASSERT((Y[0bin001110100100] & Y[0bin001111010001] = 0bin1) => final_Ey[0bin001110100100]=0bin00001111);
-ASSERT((Y[0bin001110100100] & Y[0bin001111010001] = 0bin0) => final_Ey[0bin001110100100]=0bin00000000);
-ASSERT(Y[0bin001110101100]=0bin0);
-ASSERT(Y[0bin001110101101]=0bin0);
-ASSERT((Y[0bin001111000111] & Y[0bin001111110100] = 0bin1) => final_Ey[0bin001111000111]=0bin00010111);
-ASSERT((Y[0bin001111000111] & Y[0bin001111110100] = 0bin0) => final_Ey[0bin001111000111]=0bin00000000);
-ASSERT((Y[0bin001111001101] & Y[0bin001111111010] = 0bin1) => final_Ey[0bin001111001101]=0bin00010111);
-ASSERT((Y[0bin001111001101] & Y[0bin001111111010] = 0bin0) => final_Ey[0bin001111001101]=0bin00000000);
-ASSERT((Y[0bin001111010110] & Y[0bin010000000011] = 0bin1) => final_Ey[0bin001111010110]=0bin00001110);
-ASSERT((Y[0bin001111010110] & Y[0bin010000000011] = 0bin0) => final_Ey[0bin001111010110]=0bin00000000);
-ASSERT((Y[0bin001111011000] & Y[0bin010000000101] = 0bin1) => final_Ey[0bin001111011000]=0bin00010111);
-ASSERT((Y[0bin001111011000] & Y[0bin010000000101] = 0bin0) => final_Ey[0bin001111011000]=0bin00000000);
-ASSERT(Y[0bin001111011011]=0bin0);
-ASSERT(Y[0bin001111011100]=0bin0);
-ASSERT((Y[0bin001111011111] & Y[0bin010000001100] = 0bin1) => final_Ey[0bin001111011111]=0bin00010111);
-ASSERT((Y[0bin001111011111] & Y[0bin010000001100] = 0bin0) => final_Ey[0bin001111011111]=0bin00000000);
-ASSERT((Y[0bin001111100010] & Y[0bin010000001111] = 0bin1) => final_Ey[0bin001111100010]=0bin00010111);
-ASSERT((Y[0bin001111100010] & Y[0bin010000001111] = 0bin0) => final_Ey[0bin001111100010]=0bin00000000);
-ASSERT((Y[0bin001111100101] & Y[0bin010000010010] = 0bin1) => final_Ey[0bin001111100101]=0bin00001110);
-ASSERT((Y[0bin001111100101] & Y[0bin010000010010] = 0bin0) => final_Ey[0bin001111100101]=0bin00000000);
-ASSERT((Y[0bin001111110001] & Y[0bin010000011110] = 0bin1) => final_Ey[0bin001111110001]=0bin00001110);
-ASSERT((Y[0bin001111110001] & Y[0bin010000011110] = 0bin0) => final_Ey[0bin001111110001]=0bin00000000);
-ASSERT((Y[0bin001111110011] & Y[0bin010000100000] = 0bin1) => final_Ey[0bin001111110011]=0bin00010111);
-ASSERT((Y[0bin001111110011] & Y[0bin010000100000] = 0bin0) => final_Ey[0bin001111110011]=0bin00000000);
-ASSERT((Y[0bin010000000101] & Y[0bin010000110010] = 0bin1) => final_Ey[0bin010000000101]=0bin00001110);
-ASSERT((Y[0bin010000000101] & Y[0bin010000110010] = 0bin0) => final_Ey[0bin010000000101]=0bin00000000);
-ASSERT(Y[0bin010000001010]=0bin0);
-ASSERT(Y[0bin010000001011]=0bin0);
-ASSERT((Y[0bin010000100000] & Y[0bin010001001101] = 0bin1) => final_Ey[0bin010000100000]=0bin00001110);
-ASSERT((Y[0bin010000100000] & Y[0bin010001001101] = 0bin0) => final_Ey[0bin010000100000]=0bin00000000);
-ASSERT((Y[0bin010000101010] & Y[0bin010001010111] = 0bin1) => final_Ey[0bin010000101010]=0bin00001111);
-ASSERT((Y[0bin010000101010] & Y[0bin010001010111] = 0bin0) => final_Ey[0bin010000101010]=0bin00000000);
-ASSERT((Y[0bin010000101110] & Y[0bin010001011011] = 0bin1) => final_Ey[0bin010000101110]=0bin00001111);
-ASSERT((Y[0bin010000101110] & Y[0bin010001011011] = 0bin0) => final_Ey[0bin010000101110]=0bin00000000);
-ASSERT(Y[0bin010000111001]=0bin0);
-ASSERT(Y[0bin010000111010]=0bin0);
-ASSERT((Y[0bin010001010001] & Y[0bin010001111110] = 0bin1) => final_Ey[0bin010001010001]=0bin00010111);
-ASSERT((Y[0bin010001010001] & Y[0bin010001111110] = 0bin0) => final_Ey[0bin010001010001]=0bin00000000);
-ASSERT((Y[0bin010001010111] & Y[0bin010010000100] = 0bin1) => final_Ey[0bin010001010111]=0bin00010111);
-ASSERT((Y[0bin010001010111] & Y[0bin010010000100] = 0bin0) => final_Ey[0bin010001010111]=0bin00000000);
-ASSERT((Y[0bin010001100000] & Y[0bin010010001101] = 0bin1) => final_Ey[0bin010001100000]=0bin00001110);
-ASSERT((Y[0bin010001100000] & Y[0bin010010001101] = 0bin0) => final_Ey[0bin010001100000]=0bin00000000);
-ASSERT((Y[0bin010001100010] & Y[0bin010010001111] = 0bin1) => final_Ey[0bin010001100010]=0bin00010111);
-ASSERT((Y[0bin010001100010] & Y[0bin010010001111] = 0bin0) => final_Ey[0bin010001100010]=0bin00000000);
-ASSERT((Y[0bin010001100110] & Y[0bin010010010011] = 0bin1) => final_Ey[0bin010001100110]=0bin00010111);
-ASSERT((Y[0bin010001100110] & Y[0bin010010010011] = 0bin0) => final_Ey[0bin010001100110]=0bin00000000);
-ASSERT(Y[0bin010001101000]=0bin0);
-ASSERT(Y[0bin010001101001]=0bin0);
-ASSERT((Y[0bin010001101100] & Y[0bin010010011001] = 0bin1) => final_Ey[0bin010001101100]=0bin00010111);
-ASSERT((Y[0bin010001101100] & Y[0bin010010011001] = 0bin0) => final_Ey[0bin010001101100]=0bin00000000);
-ASSERT((Y[0bin010001101111] & Y[0bin010010011100] = 0bin1) => final_Ey[0bin010001101111]=0bin00001110);
-ASSERT((Y[0bin010001101111] & Y[0bin010010011100] = 0bin0) => final_Ey[0bin010001101111]=0bin00000000);
-ASSERT((Y[0bin010001111011] & Y[0bin010010101000] = 0bin1) => final_Ey[0bin010001111011]=0bin00001110);
-ASSERT((Y[0bin010001111011] & Y[0bin010010101000] = 0bin0) => final_Ey[0bin010001111011]=0bin00000000);
-ASSERT((Y[0bin010001111101] & Y[0bin010010101010] = 0bin1) => final_Ey[0bin010001111101]=0bin00010111);
-ASSERT((Y[0bin010001111101] & Y[0bin010010101010] = 0bin0) => final_Ey[0bin010001111101]=0bin00000000);
-ASSERT((Y[0bin010010000100] & Y[0bin010010110001] = 0bin1) => final_Ey[0bin010010000100]=0bin00010000);
-ASSERT((Y[0bin010010000100] & Y[0bin010010110001] = 0bin0) => final_Ey[0bin010010000100]=0bin00000000);
-ASSERT(Y[0bin010010010111]=0bin0);
-ASSERT(Y[0bin010010011000]=0bin0);
-ASSERT((Y[0bin010010011100] & Y[0bin010011001001] = 0bin1) => final_Ey[0bin010010011100]=0bin00010000);
-ASSERT((Y[0bin010010011100] & Y[0bin010011001001] = 0bin0) => final_Ey[0bin010010011100]=0bin00000000);
-ASSERT((Y[0bin010010100100] & Y[0bin010011010001] = 0bin1) => final_Ey[0bin010010100100]=0bin00010000);
-ASSERT((Y[0bin010010100100] & Y[0bin010011010001] = 0bin0) => final_Ey[0bin010010100100]=0bin00000000);
-ASSERT((Y[0bin010010100111] & Y[0bin010011010100] = 0bin1) => final_Ey[0bin010010100111]=0bin00010000);
-ASSERT((Y[0bin010010100111] & Y[0bin010011010100] = 0bin0) => final_Ey[0bin010010100111]=0bin00000000);
-ASSERT((Y[0bin010010101000] & Y[0bin010011010101] = 0bin1) => final_Ey[0bin010010101000]=0bin00010000);
-ASSERT((Y[0bin010010101000] & Y[0bin010011010101] = 0bin0) => final_Ey[0bin010010101000]=0bin00000000);
-ASSERT((Y[0bin010010110001] & Y[0bin010011011110] = 0bin1) => final_Ey[0bin010010110001]=0bin00010111);
-ASSERT((Y[0bin010010110001] & Y[0bin010011011110] = 0bin0) => final_Ey[0bin010010110001]=0bin00000000);
-ASSERT((Y[0bin010010111011] & Y[0bin010011101000] = 0bin1) => final_Ey[0bin010010111011]=0bin00010111);
-ASSERT((Y[0bin010010111011] & Y[0bin010011101000] = 0bin0) => final_Ey[0bin010010111011]=0bin00000000);
-ASSERT((Y[0bin010010111101] & Y[0bin010011101010] = 0bin1) => final_Ey[0bin010010111101]=0bin00001110);
-ASSERT((Y[0bin010010111101] & Y[0bin010011101010] = 0bin0) => final_Ey[0bin010010111101]=0bin00000000);
-ASSERT(Y[0bin010011000110]=0bin0);
-ASSERT(Y[0bin010011000111]=0bin0);
-ASSERT((Y[0bin010011001001] & Y[0bin010011110110] = 0bin1) => final_Ey[0bin010011001001]=0bin00010111);
-ASSERT((Y[0bin010011001001] & Y[0bin010011110110] = 0bin0) => final_Ey[0bin010011001001]=0bin00000000);
-ASSERT((Y[0bin010011010001] & Y[0bin010011111110] = 0bin1) => final_Ey[0bin010011010001]=0bin00010111);
-ASSERT((Y[0bin010011010001] & Y[0bin010011111110] = 0bin0) => final_Ey[0bin010011010001]=0bin00000000);
-ASSERT((Y[0bin010011011000] & Y[0bin010100000101] = 0bin1) => final_Ey[0bin010011011000]=0bin00001110);
-ASSERT((Y[0bin010011011000] & Y[0bin010100000101] = 0bin0) => final_Ey[0bin010011011000]=0bin00000000);
-ASSERT((Y[0bin010011011011] & Y[0bin010100001000] = 0bin1) => final_Ey[0bin010011011011]=0bin00010111);
-ASSERT((Y[0bin010011011011] & Y[0bin010100001000] = 0bin0) => final_Ey[0bin010011011011]=0bin00000000);
-ASSERT((Y[0bin010011100001] & Y[0bin010100001110] = 0bin1) => final_Ey[0bin010011100001]=0bin00010111);
-ASSERT((Y[0bin010011100001] & Y[0bin010100001110] = 0bin0) => final_Ey[0bin010011100001]=0bin00000000);
-ASSERT((Y[0bin010011101010] & Y[0bin010100010111] = 0bin1) => final_Ey[0bin010011101010]=0bin00001110);
-ASSERT((Y[0bin010011101010] & Y[0bin010100010111] = 0bin0) => final_Ey[0bin010011101010]=0bin00000000);
-ASSERT((Y[0bin010011101100] & Y[0bin010100011001] = 0bin1) => final_Ey[0bin010011101100]=0bin00010111);
-ASSERT((Y[0bin010011101100] & Y[0bin010100011001] = 0bin0) => final_Ey[0bin010011101100]=0bin00000000);
-ASSERT((Y[0bin010011110000] & Y[0bin010100011101] = 0bin1) => final_Ey[0bin010011110000]=0bin00010111);
-ASSERT((Y[0bin010011110000] & Y[0bin010100011101] = 0bin0) => final_Ey[0bin010011110000]=0bin00000000);
-ASSERT((Y[0bin010011110011] & Y[0bin010100100000] = 0bin1) => final_Ey[0bin010011110011]=0bin00010111);
-ASSERT((Y[0bin010011110011] & Y[0bin010100100000] = 0bin0) => final_Ey[0bin010011110011]=0bin00000000);
-ASSERT(Y[0bin010011110101]=0bin0);
-ASSERT(Y[0bin010011110110]=0bin0);
-ASSERT((Y[0bin010011111001] & Y[0bin010100100110] = 0bin1) => final_Ey[0bin010011111001]=0bin00001110);
-ASSERT((Y[0bin010011111001] & Y[0bin010100100110] = 0bin0) => final_Ey[0bin010011111001]=0bin00000000);
-ASSERT((Y[0bin010100000101] & Y[0bin010100110010] = 0bin1) => final_Ey[0bin010100000101]=0bin00001110);
-ASSERT((Y[0bin010100000101] & Y[0bin010100110010] = 0bin0) => final_Ey[0bin010100000101]=0bin00000000);
-ASSERT((Y[0bin010100000111] & Y[0bin010100110100] = 0bin1) => final_Ey[0bin010100000111]=0bin00010111);
-ASSERT((Y[0bin010100000111] & Y[0bin010100110100] = 0bin0) => final_Ey[0bin010100000111]=0bin00000000);
-ASSERT((Y[0bin010100001101] & Y[0bin010100111010] = 0bin1) => final_Ey[0bin010100001101]=0bin00010111);
-ASSERT((Y[0bin010100001101] & Y[0bin010100111010] = 0bin0) => final_Ey[0bin010100001101]=0bin00000000);
-ASSERT((Y[0bin010100010111] & Y[0bin010101000100] = 0bin1) => final_Ey[0bin010100010111]=0bin00010111);
-ASSERT((Y[0bin010100010111] & Y[0bin010101000100] = 0bin0) => final_Ey[0bin010100010111]=0bin00000000);
-ASSERT((Y[0bin010100011001] & Y[0bin010101000110] = 0bin1) => final_Ey[0bin010100011001]=0bin00001110);
-ASSERT((Y[0bin010100011001] & Y[0bin010101000110] = 0bin0) => final_Ey[0bin010100011001]=0bin00000000);
-ASSERT((Y[0bin010100100011] & Y[0bin010101010000] = 0bin1) => final_Ey[0bin010100100011]=0bin00010111);
-ASSERT((Y[0bin010100100011] & Y[0bin010101010000] = 0bin0) => final_Ey[0bin010100100011]=0bin00000000);
-ASSERT(Y[0bin010100100100]=0bin0);
-ASSERT(Y[0bin010100100101]=0bin0);
-ASSERT((Y[0bin010100101101] & Y[0bin010101011010] = 0bin1) => final_Ey[0bin010100101101]=0bin00010111);
-ASSERT((Y[0bin010100101101] & Y[0bin010101011010] = 0bin0) => final_Ey[0bin010100101101]=0bin00000000);
-ASSERT((Y[0bin010100110100] & Y[0bin010101100001] = 0bin1) => final_Ey[0bin010100110100]=0bin00001110);
-ASSERT((Y[0bin010100110100] & Y[0bin010101100001] = 0bin0) => final_Ey[0bin010100110100]=0bin00000000);
-ASSERT((Y[0bin010100111010] & Y[0bin010101100111] = 0bin1) => final_Ey[0bin010100111010]=0bin00010111);
-ASSERT((Y[0bin010100111010] & Y[0bin010101100111] = 0bin0) => final_Ey[0bin010100111010]=0bin00000000);
-ASSERT((Y[0bin010100111110] & Y[0bin010101101011] = 0bin1) => final_Ey[0bin010100111110]=0bin00010001);
-ASSERT((Y[0bin010100111110] & Y[0bin010101101011] = 0bin0) => final_Ey[0bin010100111110]=0bin00000000);
-ASSERT((Y[0bin010101000010] & Y[0bin010101101111] = 0bin1) => final_Ey[0bin010101000010]=0bin00010001);
-ASSERT((Y[0bin010101000010] & Y[0bin010101101111] = 0bin0) => final_Ey[0bin010101000010]=0bin00000000);
-ASSERT((Y[0bin010101000011] & Y[0bin010101110000] = 0bin1) => final_Ey[0bin010101000011]=0bin00010001);
-ASSERT((Y[0bin010101000011] & Y[0bin010101110000] = 0bin0) => final_Ey[0bin010101000011]=0bin00000000);
-ASSERT((Y[0bin010101000100] & Y[0bin010101110001] = 0bin1) => final_Ey[0bin010101000100]=0bin00010111);
-ASSERT((Y[0bin010101000100] & Y[0bin010101110001] = 0bin0) => final_Ey[0bin010101000100]=0bin00000000);
-ASSERT((Y[0bin010101001001] & Y[0bin010101110110] = 0bin1) => final_Ey[0bin010101001001]=0bin00010111);
-ASSERT((Y[0bin010101001001] & Y[0bin010101110110] = 0bin0) => final_Ey[0bin010101001001]=0bin00000000);
-ASSERT((Y[0bin010101010000] & Y[0bin010101111101] = 0bin1) => final_Ey[0bin010101010000]=0bin00010111);
-ASSERT((Y[0bin010101010000] & Y[0bin010101111101] = 0bin0) => final_Ey[0bin010101010000]=0bin00000000);
-ASSERT(Y[0bin010101010011]=0bin0);
-ASSERT(Y[0bin010101010100]=0bin0);
-ASSERT((Y[0bin010101100101] & Y[0bin010110010010] = 0bin1) => final_Ey[0bin010101100101]=0bin00010000);
-ASSERT((Y[0bin010101100101] & Y[0bin010110010010] = 0bin0) => final_Ey[0bin010101100101]=0bin00000000);
-ASSERT((Y[0bin010101100111] & Y[0bin010110010100] = 0bin1) => final_Ey[0bin010101100111]=0bin00001010);
-ASSERT((Y[0bin010101100111] & Y[0bin010110010100] = 0bin0) => final_Ey[0bin010101100111]=0bin00000000);
-ASSERT((Y[0bin010101101011] & Y[0bin010110011000] = 0bin1) => final_Ey[0bin010101101011]=0bin00010000);
-ASSERT((Y[0bin010101101011] & Y[0bin010110011000] = 0bin0) => final_Ey[0bin010101101011]=0bin00000000);
-ASSERT((Y[0bin010101101111] & Y[0bin010110011100] = 0bin1) => final_Ey[0bin010101101111]=0bin00001010);
-ASSERT((Y[0bin010101101111] & Y[0bin010110011100] = 0bin0) => final_Ey[0bin010101101111]=0bin00000000);
-ASSERT((Y[0bin010101110100] & Y[0bin010110100001] = 0bin1) => final_Ey[0bin010101110100]=0bin00001001);
-ASSERT((Y[0bin010101110100] & Y[0bin010110100001] = 0bin0) => final_Ey[0bin010101110100]=0bin00000000);
-ASSERT((Y[0bin010101110110] & Y[0bin010110100011] = 0bin1) => final_Ey[0bin010101110110]=0bin00010000);
-ASSERT((Y[0bin010101110110] & Y[0bin010110100011] = 0bin0) => final_Ey[0bin010101110110]=0bin00000000);
-ASSERT((Y[0bin010101111010] & Y[0bin010110100111] = 0bin1) => final_Ey[0bin010101111010]=0bin00010000);
-ASSERT((Y[0bin010101111010] & Y[0bin010110100111] = 0bin0) => final_Ey[0bin010101111010]=0bin00000000);
-ASSERT((Y[0bin010101111101] & Y[0bin010110101010] = 0bin1) => final_Ey[0bin010101111101]=0bin00010000);
-ASSERT((Y[0bin010101111101] & Y[0bin010110101010] = 0bin0) => final_Ey[0bin010101111101]=0bin00000000);
-ASSERT((Y[0bin010110000000] & Y[0bin010110101101] = 0bin1) => final_Ey[0bin010110000000]=0bin00010000);
-ASSERT((Y[0bin010110000000] & Y[0bin010110101101] = 0bin0) => final_Ey[0bin010110000000]=0bin00000000);
-ASSERT(Y[0bin010110000010]=0bin0);
-ASSERT(Y[0bin010110000011]=0bin0);
-ASSERT((Y[0bin010110000110] & Y[0bin010110110011] = 0bin1) => final_Ey[0bin010110000110]=0bin00000011);
-ASSERT((Y[0bin010110000110] & Y[0bin010110110011] = 0bin0) => final_Ey[0bin010110000110]=0bin00000000);
-ASSERT((Y[0bin010110001000] & Y[0bin010110110101] = 0bin1) => final_Ey[0bin010110001000]=0bin00001010);
-ASSERT((Y[0bin010110001000] & Y[0bin010110110101] = 0bin0) => final_Ey[0bin010110001000]=0bin00000000);
-ASSERT((Y[0bin010110001111] & Y[0bin010110111100] = 0bin1) => final_Ey[0bin010110001111]=0bin00001001);
-ASSERT((Y[0bin010110001111] & Y[0bin010110111100] = 0bin0) => final_Ey[0bin010110001111]=0bin00000000);
-ASSERT((Y[0bin010110010001] & Y[0bin010110111110] = 0bin1) => final_Ey[0bin010110010001]=0bin00010000);
-ASSERT((Y[0bin010110010001] & Y[0bin010110111110] = 0bin0) => final_Ey[0bin010110010001]=0bin00000000);
-ASSERT((Y[0bin010110011011] & Y[0bin010111001000] = 0bin1) => final_Ey[0bin010110011011]=0bin00000100);
-ASSERT((Y[0bin010110011011] & Y[0bin010111001000] = 0bin0) => final_Ey[0bin010110011011]=0bin00000000);
-ASSERT((Y[0bin010110100011] & Y[0bin010111010000] = 0bin1) => final_Ey[0bin010110100011]=0bin00000110);
-ASSERT((Y[0bin010110100011] & Y[0bin010111010000] = 0bin0) => final_Ey[0bin010110100011]=0bin00000000);
-ASSERT(Y[0bin010110110001]=0bin0);
-ASSERT(Y[0bin010110110010]=0bin0);
-ASSERT((Y[0bin010110110101] & Y[0bin010111100010] = 0bin1) => final_Ey[0bin010110110101]=0bin00000100);
-ASSERT((Y[0bin010110110101] & Y[0bin010111100010] = 0bin0) => final_Ey[0bin010110110101]=0bin00000000);
-ASSERT((Y[0bin010110111110] & Y[0bin010111101011] = 0bin1) => final_Ey[0bin010110111110]=0bin00000110);
-ASSERT((Y[0bin010110111110] & Y[0bin010111101011] = 0bin0) => final_Ey[0bin010110111110]=0bin00000000);
-ASSERT(Y[0bin010111100000]=0bin0);
-ASSERT(Y[0bin010111100001]=0bin0);
-ASSERT((Y[0bin010111111110] & Y[0bin011000101011] = 0bin1) => final_Ey[0bin010111111110]=0bin00000110);
-ASSERT((Y[0bin010111111110] & Y[0bin011000101011] = 0bin0) => final_Ey[0bin010111111110]=0bin00000000);
-ASSERT((Y[0bin011000001101] & Y[0bin011000111010] = 0bin1) => final_Ey[0bin011000001101]=0bin00000110);
-ASSERT((Y[0bin011000001101] & Y[0bin011000111010] = 0bin0) => final_Ey[0bin011000001101]=0bin00000000);
-ASSERT(Y[0bin011000001111]=0bin0);
-ASSERT(Y[0bin011000010000]=0bin0);
-ASSERT((Y[0bin011000011001] & Y[0bin011001000110] = 0bin1) => final_Ey[0bin011000011001]=0bin00000110);
-ASSERT((Y[0bin011000011001] & Y[0bin011001000110] = 0bin0) => final_Ey[0bin011000011001]=0bin00000000);
-ASSERT((Y[0bin011000100101] & Y[0bin011001010010] = 0bin1) => final_Ey[0bin011000100101]=0bin00000100);
-ASSERT((Y[0bin011000100101] & Y[0bin011001010010] = 0bin0) => final_Ey[0bin011000100101]=0bin00000000);
-ASSERT((Y[0bin011000101101] & Y[0bin011001011010] = 0bin1) => final_Ey[0bin011000101101]=0bin00000110);
-ASSERT((Y[0bin011000101101] & Y[0bin011001011010] = 0bin0) => final_Ey[0bin011000101101]=0bin00000000);
-ASSERT((Y[0bin011000111100] & Y[0bin011001101001] = 0bin1) => final_Ey[0bin011000111100]=0bin00000100);
-ASSERT((Y[0bin011000111100] & Y[0bin011001101001] = 0bin0) => final_Ey[0bin011000111100]=0bin00000000);
-ASSERT(Y[0bin011000111110]=0bin0);
-ASSERT(Y[0bin011000111111]=0bin0);
-ASSERT((Y[0bin011001001000] & Y[0bin011001110101] = 0bin1) => final_Ey[0bin011001001000]=0bin00000110);
-ASSERT((Y[0bin011001001000] & Y[0bin011001110101] = 0bin0) => final_Ey[0bin011001001000]=0bin00000000);
-ASSERT((Y[0bin011001011010] & Y[0bin011010000111] = 0bin1) => final_Ey[0bin011001011010]=0bin00001110);
-ASSERT((Y[0bin011001011010] & Y[0bin011010000111] = 0bin0) => final_Ey[0bin011001011010]=0bin00000000);
-ASSERT((Y[0bin011001101001] & Y[0bin011010010110] = 0bin1) => final_Ey[0bin011001101001]=0bin00001110);
-ASSERT((Y[0bin011001101001] & Y[0bin011010010110] = 0bin0) => final_Ey[0bin011001101001]=0bin00000000);
-ASSERT(Y[0bin011001101101]=0bin0);
-ASSERT(Y[0bin011001101110]=0bin0);
-ASSERT((Y[0bin011001110101] & Y[0bin011010100010] = 0bin1) => final_Ey[0bin011001110101]=0bin00001110);
-ASSERT((Y[0bin011001110101] & Y[0bin011010100010] = 0bin0) => final_Ey[0bin011001110101]=0bin00000000);
-ASSERT((Y[0bin011001111101] & Y[0bin011010101010] = 0bin1) => final_Ey[0bin011001111101]=0bin00010111);
-ASSERT((Y[0bin011001111101] & Y[0bin011010101010] = 0bin0) => final_Ey[0bin011001111101]=0bin00000000);
-ASSERT((Y[0bin011010000111] & Y[0bin011010110100] = 0bin1) => final_Ey[0bin011010000111]=0bin00010111);
-ASSERT((Y[0bin011010000111] & Y[0bin011010110100] = 0bin0) => final_Ey[0bin011010000111]=0bin00000000);
-ASSERT((Y[0bin011010001001] & Y[0bin011010110110] = 0bin1) => final_Ey[0bin011010001001]=0bin00001110);
-ASSERT((Y[0bin011010001001] & Y[0bin011010110110] = 0bin0) => final_Ey[0bin011010001001]=0bin00000000);
-ASSERT((Y[0bin011010010011] & Y[0bin011011000000] = 0bin1) => final_Ey[0bin011010010011]=0bin00010111);
-ASSERT((Y[0bin011010010011] & Y[0bin011011000000] = 0bin0) => final_Ey[0bin011010010011]=0bin00000000);
-ASSERT((Y[0bin011010010101] & Y[0bin011011000010] = 0bin1) => final_Ey[0bin011010010101]=0bin00010111);
-ASSERT((Y[0bin011010010101] & Y[0bin011011000010] = 0bin0) => final_Ey[0bin011010010101]=0bin00000000);
-ASSERT(Y[0bin011010011100]=0bin0);
-ASSERT(Y[0bin011010011101]=0bin0);
-ASSERT((Y[0bin011010100100] & Y[0bin011011010001] = 0bin1) => final_Ey[0bin011010100100]=0bin00001110);
-ASSERT((Y[0bin011010100100] & Y[0bin011011010001] = 0bin0) => final_Ey[0bin011010100100]=0bin00000000);
-ASSERT((Y[0bin011010101010] & Y[0bin011011010111] = 0bin1) => final_Ey[0bin011010101010]=0bin00010111);
-ASSERT((Y[0bin011010101010] & Y[0bin011011010111] = 0bin0) => final_Ey[0bin011010101010]=0bin00000000);
-ASSERT((Y[0bin011010101110] & Y[0bin011011011011] = 0bin1) => final_Ey[0bin011010101110]=0bin00010001);
-ASSERT((Y[0bin011010101110] & Y[0bin011011011011] = 0bin0) => final_Ey[0bin011010101110]=0bin00000000);
-ASSERT((Y[0bin011010110010] & Y[0bin011011011111] = 0bin1) => final_Ey[0bin011010110010]=0bin00010001);
-ASSERT((Y[0bin011010110010] & Y[0bin011011011111] = 0bin0) => final_Ey[0bin011010110010]=0bin00000000);
-ASSERT((Y[0bin011010110011] & Y[0bin011011100000] = 0bin1) => final_Ey[0bin011010110011]=0bin00010001);
-ASSERT((Y[0bin011010110011] & Y[0bin011011100000] = 0bin0) => final_Ey[0bin011010110011]=0bin00000000);
-ASSERT((Y[0bin011010110100] & Y[0bin011011100001] = 0bin1) => final_Ey[0bin011010110100]=0bin00010111);
-ASSERT((Y[0bin011010110100] & Y[0bin011011100001] = 0bin0) => final_Ey[0bin011010110100]=0bin00000000);
-ASSERT((Y[0bin011010111001] & Y[0bin011011100110] = 0bin1) => final_Ey[0bin011010111001]=0bin00010111);
-ASSERT((Y[0bin011010111001] & Y[0bin011011100110] = 0bin0) => final_Ey[0bin011010111001]=0bin00000000);
-ASSERT((Y[0bin011011000000] & Y[0bin011011101101] = 0bin1) => final_Ey[0bin011011000000]=0bin00010111);
-ASSERT((Y[0bin011011000000] & Y[0bin011011101101] = 0bin0) => final_Ey[0bin011011000000]=0bin00000000);
-ASSERT(Y[0bin011011001011]=0bin0);
-ASSERT(Y[0bin011011001100]=0bin0);
-ASSERT((Y[0bin011011100001] & Y[0bin011100001110] = 0bin1) => final_Ey[0bin011011100001]=0bin00001111);
-ASSERT((Y[0bin011011100001] & Y[0bin011100001110] = 0bin0) => final_Ey[0bin011011100001]=0bin00000000);
-ASSERT(Y[0bin011011111010]=0bin0);
-ASSERT(Y[0bin011011111011]=0bin0);
-ASSERT((Y[0bin011100001010] & Y[0bin011100110111] = 0bin1) => final_Ey[0bin011100001010]=0bin00001111);
-ASSERT((Y[0bin011100001010] & Y[0bin011100110111] = 0bin0) => final_Ey[0bin011100001010]=0bin00000000);
-ASSERT((Y[0bin011100001110] & Y[0bin011100111011] = 0bin1) => final_Ey[0bin011100001110]=0bin00001111);
-ASSERT((Y[0bin011100001110] & Y[0bin011100111011] = 0bin0) => final_Ey[0bin011100001110]=0bin00000000);
-ASSERT(Y[0bin011100101001]=0bin0);
-ASSERT(Y[0bin011100101010]=0bin0);
-ASSERT((Y[0bin011100110100] & Y[0bin011101100001] = 0bin1) => final_Ey[0bin011100110100]=0bin00010111);
-ASSERT((Y[0bin011100110100] & Y[0bin011101100001] = 0bin0) => final_Ey[0bin011100110100]=0bin00000000);
-ASSERT((Y[0bin011100111000] & Y[0bin011101100101] = 0bin1) => final_Ey[0bin011100111000]=0bin00010001);
-ASSERT((Y[0bin011100111000] & Y[0bin011101100101] = 0bin0) => final_Ey[0bin011100111000]=0bin00000000);
-ASSERT((Y[0bin011100111100] & Y[0bin011101101001] = 0bin1) => final_Ey[0bin011100111100]=0bin00010001);
-ASSERT((Y[0bin011100111100] & Y[0bin011101101001] = 0bin0) => final_Ey[0bin011100111100]=0bin00000000);
-ASSERT((Y[0bin011100111101] & Y[0bin011101101010] = 0bin1) => final_Ey[0bin011100111101]=0bin00010001);
-ASSERT((Y[0bin011100111101] & Y[0bin011101101010] = 0bin0) => final_Ey[0bin011100111101]=0bin00000000);
-ASSERT((Y[0bin011100111110] & Y[0bin011101101011] = 0bin1) => final_Ey[0bin011100111110]=0bin00010111);
-ASSERT((Y[0bin011100111110] & Y[0bin011101101011] = 0bin0) => final_Ey[0bin011100111110]=0bin00000000);
-ASSERT((Y[0bin011101000011] & Y[0bin011101110000] = 0bin1) => final_Ey[0bin011101000011]=0bin00010111);
-ASSERT((Y[0bin011101000011] & Y[0bin011101110000] = 0bin0) => final_Ey[0bin011101000011]=0bin00000000);
-ASSERT((Y[0bin011101001010] & Y[0bin011101110111] = 0bin1) => final_Ey[0bin011101001010]=0bin00010111);
-ASSERT((Y[0bin011101001010] & Y[0bin011101110111] = 0bin0) => final_Ey[0bin011101001010]=0bin00000000);
-ASSERT(Y[0bin011101011000]=0bin0);
-ASSERT(Y[0bin011101011001]=0bin0);
-ASSERT((Y[0bin011101100010] & Y[0bin011110001111] = 0bin1) => final_Ey[0bin011101100010]=0bin00010111);
-ASSERT((Y[0bin011101100010] & Y[0bin011110001111] = 0bin0) => final_Ey[0bin011101100010]=0bin00000000);
-ASSERT((Y[0bin011101100110] & Y[0bin011110010011] = 0bin1) => final_Ey[0bin011101100110]=0bin00010001);
-ASSERT((Y[0bin011101100110] & Y[0bin011110010011] = 0bin0) => final_Ey[0bin011101100110]=0bin00000000);
-ASSERT((Y[0bin011101101010] & Y[0bin011110010111] = 0bin1) => final_Ey[0bin011101101010]=0bin00010001);
-ASSERT((Y[0bin011101101010] & Y[0bin011110010111] = 0bin0) => final_Ey[0bin011101101010]=0bin00000000);
-ASSERT((Y[0bin011101101011] & Y[0bin011110011000] = 0bin1) => final_Ey[0bin011101101011]=0bin00010001);
-ASSERT((Y[0bin011101101011] & Y[0bin011110011000] = 0bin0) => final_Ey[0bin011101101011]=0bin00000000);
-ASSERT((Y[0bin011101101100] & Y[0bin011110011001] = 0bin1) => final_Ey[0bin011101101100]=0bin00010111);
-ASSERT((Y[0bin011101101100] & Y[0bin011110011001] = 0bin0) => final_Ey[0bin011101101100]=0bin00000000);
-ASSERT((Y[0bin011101110001] & Y[0bin011110011110] = 0bin1) => final_Ey[0bin011101110001]=0bin00010111);
-ASSERT((Y[0bin011101110001] & Y[0bin011110011110] = 0bin0) => final_Ey[0bin011101110001]=0bin00000000);
-ASSERT((Y[0bin011101111000] & Y[0bin011110100101] = 0bin1) => final_Ey[0bin011101111000]=0bin00010111);
-ASSERT((Y[0bin011101111000] & Y[0bin011110100101] = 0bin0) => final_Ey[0bin011101111000]=0bin00000000);
-ASSERT(Y[0bin011110000111]=0bin0);
-ASSERT(Y[0bin011110001000]=0bin0);
-ASSERT((Y[0bin011110001101] & Y[0bin011110111010] = 0bin1) => final_Ey[0bin011110001101]=0bin00010000);
-ASSERT((Y[0bin011110001101] & Y[0bin011110111010] = 0bin0) => final_Ey[0bin011110001101]=0bin00000000);
-ASSERT((Y[0bin011110001111] & Y[0bin011110111100] = 0bin1) => final_Ey[0bin011110001111]=0bin00001010);
-ASSERT((Y[0bin011110001111] & Y[0bin011110111100] = 0bin0) => final_Ey[0bin011110001111]=0bin00000000);
-ASSERT((Y[0bin011110010011] & Y[0bin011111000000] = 0bin1) => final_Ey[0bin011110010011]=0bin00010000);
-ASSERT((Y[0bin011110010011] & Y[0bin011111000000] = 0bin0) => final_Ey[0bin011110010011]=0bin00000000);
-ASSERT((Y[0bin011110010111] & Y[0bin011111000100] = 0bin1) => final_Ey[0bin011110010111]=0bin00001010);
-ASSERT((Y[0bin011110010111] & Y[0bin011111000100] = 0bin0) => final_Ey[0bin011110010111]=0bin00000000);
-ASSERT((Y[0bin011110011100] & Y[0bin011111001001] = 0bin1) => final_Ey[0bin011110011100]=0bin00001001);
-ASSERT((Y[0bin011110011100] & Y[0bin011111001001] = 0bin0) => final_Ey[0bin011110011100]=0bin00000000);
-ASSERT((Y[0bin011110011110] & Y[0bin011111001011] = 0bin1) => final_Ey[0bin011110011110]=0bin00010000);
-ASSERT((Y[0bin011110011110] & Y[0bin011111001011] = 0bin0) => final_Ey[0bin011110011110]=0bin00000000);
-ASSERT((Y[0bin011110100010] & Y[0bin011111001111] = 0bin1) => final_Ey[0bin011110100010]=0bin00010000);
-ASSERT((Y[0bin011110100010] & Y[0bin011111001111] = 0bin0) => final_Ey[0bin011110100010]=0bin00000000);
-ASSERT((Y[0bin011110100101] & Y[0bin011111010010] = 0bin1) => final_Ey[0bin011110100101]=0bin00010000);
-ASSERT((Y[0bin011110100101] & Y[0bin011111010010] = 0bin0) => final_Ey[0bin011110100101]=0bin00000000);
-ASSERT((Y[0bin011110101000] & Y[0bin011111010101] = 0bin1) => final_Ey[0bin011110101000]=0bin00010000);
-ASSERT((Y[0bin011110101000] & Y[0bin011111010101] = 0bin0) => final_Ey[0bin011110101000]=0bin00000000);
-ASSERT((Y[0bin011110101011] & Y[0bin011111011000] = 0bin1) => final_Ey[0bin011110101011]=0bin00001001);
-ASSERT((Y[0bin011110101011] & Y[0bin011111011000] = 0bin0) => final_Ey[0bin011110101011]=0bin00000000);
-ASSERT((Y[0bin011110101110] & Y[0bin011111011011] = 0bin1) => final_Ey[0bin011110101110]=0bin00000011);
-ASSERT((Y[0bin011110101110] & Y[0bin011111011011] = 0bin0) => final_Ey[0bin011110101110]=0bin00000000);
-ASSERT((Y[0bin011110110000] & Y[0bin011111011101] = 0bin1) => final_Ey[0bin011110110000]=0bin00001010);
-ASSERT((Y[0bin011110110000] & Y[0bin011111011101] = 0bin0) => final_Ey[0bin011110110000]=0bin00000000);
-ASSERT(Y[0bin011110110110]=0bin0);
-ASSERT(Y[0bin011110110111]=0bin0);
-ASSERT((Y[0bin011110111001] & Y[0bin011111100110] = 0bin1) => final_Ey[0bin011110111001]=0bin00010000);
-ASSERT((Y[0bin011110111001] & Y[0bin011111100110] = 0bin0) => final_Ey[0bin011110111001]=0bin00000000);
-ASSERT((Y[0bin011110111100] & Y[0bin011111101001] = 0bin1) => final_Ey[0bin011110111100]=0bin00001010);
-ASSERT((Y[0bin011110111100] & Y[0bin011111101001] = 0bin0) => final_Ey[0bin011110111100]=0bin00000000);
-ASSERT((Y[0bin011110111111] & Y[0bin011111101100] = 0bin1) => final_Ey[0bin011110111111]=0bin00010000);
-ASSERT((Y[0bin011110111111] & Y[0bin011111101100] = 0bin0) => final_Ey[0bin011110111111]=0bin00000000);
-ASSERT((Y[0bin011111000011] & Y[0bin011111110000] = 0bin1) => final_Ey[0bin011111000011]=0bin00000011);
-ASSERT((Y[0bin011111000011] & Y[0bin011111110000] = 0bin0) => final_Ey[0bin011111000011]=0bin00000000);
-ASSERT((Y[0bin011111001001] & Y[0bin011111110110] = 0bin1) => final_Ey[0bin011111001001]=0bin00010000);
-ASSERT((Y[0bin011111001001] & Y[0bin011111110110] = 0bin0) => final_Ey[0bin011111001001]=0bin00000000);
-ASSERT((Y[0bin011111001011] & Y[0bin011111111000] = 0bin1) => final_Ey[0bin011111001011]=0bin00001001);
-ASSERT((Y[0bin011111001011] & Y[0bin011111111000] = 0bin0) => final_Ey[0bin011111001011]=0bin00000000);
-ASSERT((Y[0bin011111001110] & Y[0bin011111111011] = 0bin1) => final_Ey[0bin011111001110]=0bin00001010);
-ASSERT((Y[0bin011111001110] & Y[0bin011111111011] = 0bin0) => final_Ey[0bin011111001110]=0bin00000000);
-ASSERT((Y[0bin011111010001] & Y[0bin011111111110] = 0bin1) => final_Ey[0bin011111010001]=0bin00001010);
-ASSERT((Y[0bin011111010001] & Y[0bin011111111110] = 0bin0) => final_Ey[0bin011111010001]=0bin00000000);
-ASSERT((Y[0bin011111010101] & Y[0bin100000000010] = 0bin1) => final_Ey[0bin011111010101]=0bin00010000);
-ASSERT((Y[0bin011111010101] & Y[0bin100000000010] = 0bin0) => final_Ey[0bin011111010101]=0bin00000000);
-ASSERT((Y[0bin011111010111] & Y[0bin100000000100] = 0bin1) => final_Ey[0bin011111010111]=0bin00010000);
-ASSERT((Y[0bin011111010111] & Y[0bin100000000100] = 0bin0) => final_Ey[0bin011111010111]=0bin00000000);
-ASSERT((Y[0bin011111011010] & Y[0bin100000000111] = 0bin1) => final_Ey[0bin011111011010]=0bin00000011);
-ASSERT((Y[0bin011111011010] & Y[0bin100000000111] = 0bin0) => final_Ey[0bin011111011010]=0bin00000000);
-ASSERT((Y[0bin011111011101] & Y[0bin100000001010] = 0bin1) => final_Ey[0bin011111011101]=0bin00000011);
-ASSERT((Y[0bin011111011101] & Y[0bin100000001010] = 0bin0) => final_Ey[0bin011111011101]=0bin00000000);
-ASSERT((Y[0bin011111011111] & Y[0bin100000001100] = 0bin1) => final_Ey[0bin011111011111]=0bin00010000);
-ASSERT((Y[0bin011111011111] & Y[0bin100000001100] = 0bin0) => final_Ey[0bin011111011111]=0bin00000000);
-ASSERT(Y[0bin011111100101]=0bin0);
-ASSERT(Y[0bin011111100110]=0bin0);
-ASSERT((Y[0bin011111101001] & Y[0bin100000010110] = 0bin1) => final_Ey[0bin011111101001]=0bin00010111);
-ASSERT((Y[0bin011111101001] & Y[0bin100000010110] = 0bin0) => final_Ey[0bin011111101001]=0bin00000000);
-ASSERT((Y[0bin011111101111] & Y[0bin100000011100] = 0bin1) => final_Ey[0bin011111101111]=0bin00010111);
-ASSERT((Y[0bin011111101111] & Y[0bin100000011100] = 0bin0) => final_Ey[0bin011111101111]=0bin00000000);
-ASSERT((Y[0bin011111111000] & Y[0bin100000100101] = 0bin1) => final_Ey[0bin011111111000]=0bin00001110);
-ASSERT((Y[0bin011111111000] & Y[0bin100000100101] = 0bin0) => final_Ey[0bin011111111000]=0bin00000000);
-ASSERT((Y[0bin011111111010] & Y[0bin100000100111] = 0bin1) => final_Ey[0bin011111111010]=0bin00010111);
-ASSERT((Y[0bin011111111010] & Y[0bin100000100111] = 0bin0) => final_Ey[0bin011111111010]=0bin00000000);
-ASSERT((Y[0bin011111111110] & Y[0bin100000101011] = 0bin1) => final_Ey[0bin011111111110]=0bin00010111);
-ASSERT((Y[0bin011111111110] & Y[0bin100000101011] = 0bin0) => final_Ey[0bin011111111110]=0bin00000000);
-ASSERT((Y[0bin100000000001] & Y[0bin100000101110] = 0bin1) => final_Ey[0bin100000000001]=0bin00010111);
-ASSERT((Y[0bin100000000001] & Y[0bin100000101110] = 0bin0) => final_Ey[0bin100000000001]=0bin00000000);
-ASSERT((Y[0bin100000000100] & Y[0bin100000110001] = 0bin1) => final_Ey[0bin100000000100]=0bin00010111);
-ASSERT((Y[0bin100000000100] & Y[0bin100000110001] = 0bin0) => final_Ey[0bin100000000100]=0bin00000000);
-ASSERT((Y[0bin100000000111] & Y[0bin100000110100] = 0bin1) => final_Ey[0bin100000000111]=0bin00001110);
-ASSERT((Y[0bin100000000111] & Y[0bin100000110100] = 0bin0) => final_Ey[0bin100000000111]=0bin00000000);
-ASSERT((Y[0bin100000010011] & Y[0bin100001000000] = 0bin1) => final_Ey[0bin100000010011]=0bin00001110);
-ASSERT((Y[0bin100000010011] & Y[0bin100001000000] = 0bin0) => final_Ey[0bin100000010011]=0bin00000000);
-ASSERT(Y[0bin100000010100]=0bin0);
-ASSERT(Y[0bin100000010101]=0bin0);
-ASSERT(Y[0bin100001000011]=0bin0);
-%%%%%%%%%% (3) %%%%%%%%%%
-ASSERT (
-FOR(i:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(j:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(k:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001;EXCEPT i=j OR j=k OR i=k){
- LET ik = (BVPLUS(12, BVMULT(12, i,0bin000000101110), k)) IN
- LET ji = (BVPLUS(12, BVMULT(12, j,0bin000000101110), i)) IN
- X[ji] & X[ik] = 0bin0 AND
- Y[ji] & Y[ik] = 0bin0 AND
- Y[ji] & X[ik] = 0bin0 AND
- X[ji] & Y[ik] = 0bin0
-} } } );
-%%%%%%%%%% (4) %%%%%%%%%%
-ASSERT((X[0bin000000000001] & Y[0bin000000000001]) = 0bin0);
-ASSERT((X[0bin000000000010] & Y[0bin000000000010]) = 0bin0);
-ASSERT((X[0bin000000000011] & Y[0bin000000000011]) = 0bin0);
-ASSERT((X[0bin000000000100] & Y[0bin000000000100]) = 0bin0);
-ASSERT((X[0bin000000000101] & Y[0bin000000000101]) = 0bin0);
-ASSERT((X[0bin000000000110] & Y[0bin000000000110]) = 0bin0);
-ASSERT((X[0bin000000000111] & Y[0bin000000000111]) = 0bin0);
-ASSERT((X[0bin000000001000] & Y[0bin000000001000]) = 0bin0);
-ASSERT((X[0bin000000001001] & Y[0bin000000001001]) = 0bin0);
-ASSERT((X[0bin000000001010] & Y[0bin000000001010]) = 0bin0);
-ASSERT((X[0bin000000001011] & Y[0bin000000001011]) = 0bin0);
-ASSERT((X[0bin000000001100] & Y[0bin000000001100]) = 0bin0);
-ASSERT((X[0bin000000001101] & Y[0bin000000001101]) = 0bin0);
-ASSERT((X[0bin000000001110] & Y[0bin000000001110]) = 0bin0);
-ASSERT((X[0bin000000001111] & Y[0bin000000001111]) = 0bin0);
-ASSERT((X[0bin000000010000] & Y[0bin000000010000]) = 0bin0);
-ASSERT((X[0bin000000010001] & Y[0bin000000010001]) = 0bin0);
-ASSERT((X[0bin000000010010] & Y[0bin000000010010]) = 0bin0);
-ASSERT((X[0bin000000010011] & Y[0bin000000010011]) = 0bin0);
-ASSERT((X[0bin000000010100] & Y[0bin000000010100]) = 0bin0);
-ASSERT((X[0bin000000010101] & Y[0bin000000010101]) = 0bin0);
-ASSERT((X[0bin000000010110] & Y[0bin000000010110]) = 0bin0);
-ASSERT((X[0bin000000010111] & Y[0bin000000010111]) = 0bin0);
-ASSERT((X[0bin000000011000] & Y[0bin000000011000]) = 0bin0);
-ASSERT((X[0bin000000011001] & Y[0bin000000011001]) = 0bin0);
-ASSERT((X[0bin000000011010] & Y[0bin000000011010]) = 0bin0);
-ASSERT((X[0bin000000011011] & Y[0bin000000011011]) = 0bin0);
-ASSERT((X[0bin000000011100] & Y[0bin000000011100]) = 0bin0);
-ASSERT((X[0bin000000011101] & Y[0bin000000011101]) = 0bin0);
-ASSERT((X[0bin000000011110] & Y[0bin000000011110]) = 0bin0);
-ASSERT((X[0bin000000011111] & Y[0bin000000011111]) = 0bin0);
-ASSERT((X[0bin000000100000] & Y[0bin000000100000]) = 0bin0);
-ASSERT((X[0bin000000100001] & Y[0bin000000100001]) = 0bin0);
-ASSERT((X[0bin000000100010] & Y[0bin000000100010]) = 0bin0);
-ASSERT((X[0bin000000100011] & Y[0bin000000100011]) = 0bin0);
-ASSERT((X[0bin000000100100] & Y[0bin000000100100]) = 0bin0);
-ASSERT((X[0bin000000100101] & Y[0bin000000100101]) = 0bin0);
-ASSERT((X[0bin000000100110] & Y[0bin000000100110]) = 0bin0);
-ASSERT((X[0bin000000100111] & Y[0bin000000100111]) = 0bin0);
-ASSERT((X[0bin000000101000] & Y[0bin000000101000]) = 0bin0);
-ASSERT((X[0bin000000101001] & Y[0bin000000101001]) = 0bin0);
-ASSERT((X[0bin000000101010] & Y[0bin000000101010]) = 0bin0);
-ASSERT((X[0bin000000101011] & Y[0bin000000101011]) = 0bin0);
-ASSERT((X[0bin000000101100] & Y[0bin000000101100]) = 0bin0);
-ASSERT((X[0bin000000101101] & Y[0bin000000101101]) = 0bin0);
-ASSERT((X[0bin000000101110] & Y[0bin000000101110]) = 0bin0);
-ASSERT((X[0bin000000110000] & Y[0bin000000110000]) = 0bin0);
-ASSERT((X[0bin000000110001] & Y[0bin000000110001]) = 0bin0);
-ASSERT((X[0bin000000110010] & Y[0bin000000110010]) = 0bin0);
-ASSERT((X[0bin000000110011] & Y[0bin000000110011]) = 0bin0);
-ASSERT((X[0bin000000110100] & Y[0bin000000110100]) = 0bin0);
-ASSERT((X[0bin000000110101] & Y[0bin000000110101]) = 0bin0);
-ASSERT((X[0bin000000110110] & Y[0bin000000110110]) = 0bin0);
-ASSERT((X[0bin000000110111] & Y[0bin000000110111]) = 0bin0);
-ASSERT((X[0bin000000111000] & Y[0bin000000111000]) = 0bin0);
-ASSERT((X[0bin000000111001] & Y[0bin000000111001]) = 0bin0);
-ASSERT((X[0bin000000111010] & Y[0bin000000111010]) = 0bin0);
-ASSERT((X[0bin000000111011] & Y[0bin000000111011]) = 0bin0);
-ASSERT((X[0bin000000111100] & Y[0bin000000111100]) = 0bin0);
-ASSERT((X[0bin000000111101] & Y[0bin000000111101]) = 0bin0);
-ASSERT((X[0bin000000111110] & Y[0bin000000111110]) = 0bin0);
-ASSERT((X[0bin000000111111] & Y[0bin000000111111]) = 0bin0);
-ASSERT((X[0bin000001000000] & Y[0bin000001000000]) = 0bin0);
-ASSERT((X[0bin000001000001] & Y[0bin000001000001]) = 0bin0);
-ASSERT((X[0bin000001000010] & Y[0bin000001000010]) = 0bin0);
-ASSERT((X[0bin000001000011] & Y[0bin000001000011]) = 0bin0);
-ASSERT((X[0bin000001000100] & Y[0bin000001000100]) = 0bin0);
-ASSERT((X[0bin000001000101] & Y[0bin000001000101]) = 0bin0);
-ASSERT((X[0bin000001000110] & Y[0bin000001000110]) = 0bin0);
-ASSERT((X[0bin000001000111] & Y[0bin000001000111]) = 0bin0);
-ASSERT((X[0bin000001001000] & Y[0bin000001001000]) = 0bin0);
-ASSERT((X[0bin000001001001] & Y[0bin000001001001]) = 0bin0);
-ASSERT((X[0bin000001001010] & Y[0bin000001001010]) = 0bin0);
-ASSERT((X[0bin000001001011] & Y[0bin000001001011]) = 0bin0);
-ASSERT((X[0bin000001001100] & Y[0bin000001001100]) = 0bin0);
-ASSERT((X[0bin000001001101] & Y[0bin000001001101]) = 0bin0);
-ASSERT((X[0bin000001001110] & Y[0bin000001001110]) = 0bin0);
-ASSERT((X[0bin000001001111] & Y[0bin000001001111]) = 0bin0);
-ASSERT((X[0bin000001010000] & Y[0bin000001010000]) = 0bin0);
-ASSERT((X[0bin000001010001] & Y[0bin000001010001]) = 0bin0);
-ASSERT((X[0bin000001010010] & Y[0bin000001010010]) = 0bin0);
-ASSERT((X[0bin000001010011] & Y[0bin000001010011]) = 0bin0);
-ASSERT((X[0bin000001010100] & Y[0bin000001010100]) = 0bin0);
-ASSERT((X[0bin000001010101] & Y[0bin000001010101]) = 0bin0);
-ASSERT((X[0bin000001010110] & Y[0bin000001010110]) = 0bin0);
-ASSERT((X[0bin000001010111] & Y[0bin000001010111]) = 0bin0);
-ASSERT((X[0bin000001011000] & Y[0bin000001011000]) = 0bin0);
-ASSERT((X[0bin000001011001] & Y[0bin000001011001]) = 0bin0);
-ASSERT((X[0bin000001011010] & Y[0bin000001011010]) = 0bin0);
-ASSERT((X[0bin000001011011] & Y[0bin000001011011]) = 0bin0);
-ASSERT((X[0bin000001011100] & Y[0bin000001011100]) = 0bin0);
-ASSERT((X[0bin000001011101] & Y[0bin000001011101]) = 0bin0);
-ASSERT((X[0bin000001011111] & Y[0bin000001011111]) = 0bin0);
-ASSERT((X[0bin000001100000] & Y[0bin000001100000]) = 0bin0);
-ASSERT((X[0bin000001100001] & Y[0bin000001100001]) = 0bin0);
-ASSERT((X[0bin000001100010] & Y[0bin000001100010]) = 0bin0);
-ASSERT((X[0bin000001100011] & Y[0bin000001100011]) = 0bin0);
-ASSERT((X[0bin000001100100] & Y[0bin000001100100]) = 0bin0);
-ASSERT((X[0bin000001100101] & Y[0bin000001100101]) = 0bin0);
-ASSERT((X[0bin000001100110] & Y[0bin000001100110]) = 0bin0);
-ASSERT((X[0bin000001100111] & Y[0bin000001100111]) = 0bin0);
-ASSERT((X[0bin000001101000] & Y[0bin000001101000]) = 0bin0);
-ASSERT((X[0bin000001101001] & Y[0bin000001101001]) = 0bin0);
-ASSERT((X[0bin000001101010] & Y[0bin000001101010]) = 0bin0);
-ASSERT((X[0bin000001101011] & Y[0bin000001101011]) = 0bin0);
-ASSERT((X[0bin000001101100] & Y[0bin000001101100]) = 0bin0);
-ASSERT((X[0bin000001101101] & Y[0bin000001101101]) = 0bin0);
-ASSERT((X[0bin000001101110] & Y[0bin000001101110]) = 0bin0);
-ASSERT((X[0bin000001101111] & Y[0bin000001101111]) = 0bin0);
-ASSERT((X[0bin000001110000] & Y[0bin000001110000]) = 0bin0);
-ASSERT((X[0bin000001110001] & Y[0bin000001110001]) = 0bin0);
-ASSERT((X[0bin000001110010] & Y[0bin000001110010]) = 0bin0);
-ASSERT((X[0bin000001110011] & Y[0bin000001110011]) = 0bin0);
-ASSERT((X[0bin000001110100] & Y[0bin000001110100]) = 0bin0);
-ASSERT((X[0bin000001110101] & Y[0bin000001110101]) = 0bin0);
-ASSERT((X[0bin000001110110] & Y[0bin000001110110]) = 0bin0);
-ASSERT((X[0bin000001110111] & Y[0bin000001110111]) = 0bin0);
-ASSERT((X[0bin000001111000] & Y[0bin000001111000]) = 0bin0);
-ASSERT((X[0bin000001111001] & Y[0bin000001111001]) = 0bin0);
-ASSERT((X[0bin000001111010] & Y[0bin000001111010]) = 0bin0);
-ASSERT((X[0bin000001111011] & Y[0bin000001111011]) = 0bin0);
-ASSERT((X[0bin000001111100] & Y[0bin000001111100]) = 0bin0);
-ASSERT((X[0bin000001111101] & Y[0bin000001111101]) = 0bin0);
-ASSERT((X[0bin000001111110] & Y[0bin000001111110]) = 0bin0);
-ASSERT((X[0bin000001111111] & Y[0bin000001111111]) = 0bin0);
-ASSERT((X[0bin000010000000] & Y[0bin000010000000]) = 0bin0);
-ASSERT((X[0bin000010000001] & Y[0bin000010000001]) = 0bin0);
-ASSERT((X[0bin000010000010] & Y[0bin000010000010]) = 0bin0);
-ASSERT((X[0bin000010000011] & Y[0bin000010000011]) = 0bin0);
-ASSERT((X[0bin000010000100] & Y[0bin000010000100]) = 0bin0);
-ASSERT((X[0bin000010000101] & Y[0bin000010000101]) = 0bin0);
-ASSERT((X[0bin000010000110] & Y[0bin000010000110]) = 0bin0);
-ASSERT((X[0bin000010000111] & Y[0bin000010000111]) = 0bin0);
-ASSERT((X[0bin000010001000] & Y[0bin000010001000]) = 0bin0);
-ASSERT((X[0bin000010001001] & Y[0bin000010001001]) = 0bin0);
-ASSERT((X[0bin000010001010] & Y[0bin000010001010]) = 0bin0);
-ASSERT((X[0bin000010001011] & Y[0bin000010001011]) = 0bin0);
-ASSERT((X[0bin000010001100] & Y[0bin000010001100]) = 0bin0);
-ASSERT((X[0bin000010001110] & Y[0bin000010001110]) = 0bin0);
-ASSERT((X[0bin000010001111] & Y[0bin000010001111]) = 0bin0);
-ASSERT((X[0bin000010010000] & Y[0bin000010010000]) = 0bin0);
-ASSERT((X[0bin000010010001] & Y[0bin000010010001]) = 0bin0);
-ASSERT((X[0bin000010010010] & Y[0bin000010010010]) = 0bin0);
-ASSERT((X[0bin000010010011] & Y[0bin000010010011]) = 0bin0);
-ASSERT((X[0bin000010010100] & Y[0bin000010010100]) = 0bin0);
-ASSERT((X[0bin000010010101] & Y[0bin000010010101]) = 0bin0);
-ASSERT((X[0bin000010010110] & Y[0bin000010010110]) = 0bin0);
-ASSERT((X[0bin000010010111] & Y[0bin000010010111]) = 0bin0);
-ASSERT((X[0bin000010011000] & Y[0bin000010011000]) = 0bin0);
-ASSERT((X[0bin000010011001] & Y[0bin000010011001]) = 0bin0);
-ASSERT((X[0bin000010011010] & Y[0bin000010011010]) = 0bin0);
-ASSERT((X[0bin000010011011] & Y[0bin000010011011]) = 0bin0);
-ASSERT((X[0bin000010011100] & Y[0bin000010011100]) = 0bin0);
-ASSERT((X[0bin000010011101] & Y[0bin000010011101]) = 0bin0);
-ASSERT((X[0bin000010011110] & Y[0bin000010011110]) = 0bin0);
-ASSERT((X[0bin000010011111] & Y[0bin000010011111]) = 0bin0);
-ASSERT((X[0bin000010100000] & Y[0bin000010100000]) = 0bin0);
-ASSERT((X[0bin000010100001] & Y[0bin000010100001]) = 0bin0);
-ASSERT((X[0bin000010100010] & Y[0bin000010100010]) = 0bin0);
-ASSERT((X[0bin000010100011] & Y[0bin000010100011]) = 0bin0);
-ASSERT((X[0bin000010100100] & Y[0bin000010100100]) = 0bin0);
-ASSERT((X[0bin000010100101] & Y[0bin000010100101]) = 0bin0);
-ASSERT((X[0bin000010100110] & Y[0bin000010100110]) = 0bin0);
-ASSERT((X[0bin000010100111] & Y[0bin000010100111]) = 0bin0);
-ASSERT((X[0bin000010101000] & Y[0bin000010101000]) = 0bin0);
-ASSERT((X[0bin000010101001] & Y[0bin000010101001]) = 0bin0);
-ASSERT((X[0bin000010101010] & Y[0bin000010101010]) = 0bin0);
-ASSERT((X[0bin000010101011] & Y[0bin000010101011]) = 0bin0);
-ASSERT((X[0bin000010101100] & Y[0bin000010101100]) = 0bin0);
-ASSERT((X[0bin000010101101] & Y[0bin000010101101]) = 0bin0);
-ASSERT((X[0bin000010101110] & Y[0bin000010101110]) = 0bin0);
-ASSERT((X[0bin000010101111] & Y[0bin000010101111]) = 0bin0);
-ASSERT((X[0bin000010110000] & Y[0bin000010110000]) = 0bin0);
-ASSERT((X[0bin000010110001] & Y[0bin000010110001]) = 0bin0);
-ASSERT((X[0bin000010110010] & Y[0bin000010110010]) = 0bin0);
-ASSERT((X[0bin000010110011] & Y[0bin000010110011]) = 0bin0);
-ASSERT((X[0bin000010110100] & Y[0bin000010110100]) = 0bin0);
-ASSERT((X[0bin000010110101] & Y[0bin000010110101]) = 0bin0);
-ASSERT((X[0bin000010110110] & Y[0bin000010110110]) = 0bin0);
-ASSERT((X[0bin000010110111] & Y[0bin000010110111]) = 0bin0);
-ASSERT((X[0bin000010111000] & Y[0bin000010111000]) = 0bin0);
-ASSERT((X[0bin000010111001] & Y[0bin000010111001]) = 0bin0);
-ASSERT((X[0bin000010111010] & Y[0bin000010111010]) = 0bin0);
-ASSERT((X[0bin000010111011] & Y[0bin000010111011]) = 0bin0);
-ASSERT((X[0bin000010111101] & Y[0bin000010111101]) = 0bin0);
-ASSERT((X[0bin000010111110] & Y[0bin000010111110]) = 0bin0);
-ASSERT((X[0bin000010111111] & Y[0bin000010111111]) = 0bin0);
-ASSERT((X[0bin000011000000] & Y[0bin000011000000]) = 0bin0);
-ASSERT((X[0bin000011000001] & Y[0bin000011000001]) = 0bin0);
-ASSERT((X[0bin000011000010] & Y[0bin000011000010]) = 0bin0);
-ASSERT((X[0bin000011000011] & Y[0bin000011000011]) = 0bin0);
-ASSERT((X[0bin000011000100] & Y[0bin000011000100]) = 0bin0);
-ASSERT((X[0bin000011000101] & Y[0bin000011000101]) = 0bin0);
-ASSERT((X[0bin000011000110] & Y[0bin000011000110]) = 0bin0);
-ASSERT((X[0bin000011000111] & Y[0bin000011000111]) = 0bin0);
-ASSERT((X[0bin000011001000] & Y[0bin000011001000]) = 0bin0);
-ASSERT((X[0bin000011001001] & Y[0bin000011001001]) = 0bin0);
-ASSERT((X[0bin000011001010] & Y[0bin000011001010]) = 0bin0);
-ASSERT((X[0bin000011001011] & Y[0bin000011001011]) = 0bin0);
-ASSERT((X[0bin000011001100] & Y[0bin000011001100]) = 0bin0);
-ASSERT((X[0bin000011001101] & Y[0bin000011001101]) = 0bin0);
-ASSERT((X[0bin000011001110] & Y[0bin000011001110]) = 0bin0);
-ASSERT((X[0bin000011001111] & Y[0bin000011001111]) = 0bin0);
-ASSERT((X[0bin000011010000] & Y[0bin000011010000]) = 0bin0);
-ASSERT((X[0bin000011010001] & Y[0bin000011010001]) = 0bin0);
-ASSERT((X[0bin000011010010] & Y[0bin000011010010]) = 0bin0);
-ASSERT((X[0bin000011010011] & Y[0bin000011010011]) = 0bin0);
-ASSERT((X[0bin000011010100] & Y[0bin000011010100]) = 0bin0);
-ASSERT((X[0bin000011010101] & Y[0bin000011010101]) = 0bin0);
-ASSERT((X[0bin000011010110] & Y[0bin000011010110]) = 0bin0);
-ASSERT((X[0bin000011010111] & Y[0bin000011010111]) = 0bin0);
-ASSERT((X[0bin000011011000] & Y[0bin000011011000]) = 0bin0);
-ASSERT((X[0bin000011011001] & Y[0bin000011011001]) = 0bin0);
-ASSERT((X[0bin000011011010] & Y[0bin000011011010]) = 0bin0);
-ASSERT((X[0bin000011011011] & Y[0bin000011011011]) = 0bin0);
-ASSERT((X[0bin000011011100] & Y[0bin000011011100]) = 0bin0);
-ASSERT((X[0bin000011011101] & Y[0bin000011011101]) = 0bin0);
-ASSERT((X[0bin000011011110] & Y[0bin000011011110]) = 0bin0);
-ASSERT((X[0bin000011011111] & Y[0bin000011011111]) = 0bin0);
-ASSERT((X[0bin000011100000] & Y[0bin000011100000]) = 0bin0);
-ASSERT((X[0bin000011100001] & Y[0bin000011100001]) = 0bin0);
-ASSERT((X[0bin000011100010] & Y[0bin000011100010]) = 0bin0);
-ASSERT((X[0bin000011100011] & Y[0bin000011100011]) = 0bin0);
-ASSERT((X[0bin000011100100] & Y[0bin000011100100]) = 0bin0);
-ASSERT((X[0bin000011100101] & Y[0bin000011100101]) = 0bin0);
-ASSERT((X[0bin000011100110] & Y[0bin000011100110]) = 0bin0);
-ASSERT((X[0bin000011100111] & Y[0bin000011100111]) = 0bin0);
-ASSERT((X[0bin000011101000] & Y[0bin000011101000]) = 0bin0);
-ASSERT((X[0bin000011101001] & Y[0bin000011101001]) = 0bin0);
-ASSERT((X[0bin000011101010] & Y[0bin000011101010]) = 0bin0);
-ASSERT((X[0bin000011101100] & Y[0bin000011101100]) = 0bin0);
-ASSERT((X[0bin000011101101] & Y[0bin000011101101]) = 0bin0);
-ASSERT((X[0bin000011101110] & Y[0bin000011101110]) = 0bin0);
-ASSERT((X[0bin000011101111] & Y[0bin000011101111]) = 0bin0);
-ASSERT((X[0bin000011110000] & Y[0bin000011110000]) = 0bin0);
-ASSERT((X[0bin000011110001] & Y[0bin000011110001]) = 0bin0);
-ASSERT((X[0bin000011110010] & Y[0bin000011110010]) = 0bin0);
-ASSERT((X[0bin000011110011] & Y[0bin000011110011]) = 0bin0);
-ASSERT((X[0bin000011110100] & Y[0bin000011110100]) = 0bin0);
-ASSERT((X[0bin000011110101] & Y[0bin000011110101]) = 0bin0);
-ASSERT((X[0bin000011110110] & Y[0bin000011110110]) = 0bin0);
-ASSERT((X[0bin000011110111] & Y[0bin000011110111]) = 0bin0);
-ASSERT((X[0bin000011111000] & Y[0bin000011111000]) = 0bin0);
-ASSERT((X[0bin000011111001] & Y[0bin000011111001]) = 0bin0);
-ASSERT((X[0bin000011111010] & Y[0bin000011111010]) = 0bin0);
-ASSERT((X[0bin000011111011] & Y[0bin000011111011]) = 0bin0);
-ASSERT((X[0bin000011111100] & Y[0bin000011111100]) = 0bin0);
-ASSERT((X[0bin000011111101] & Y[0bin000011111101]) = 0bin0);
-ASSERT((X[0bin000011111110] & Y[0bin000011111110]) = 0bin0);
-ASSERT((X[0bin000011111111] & Y[0bin000011111111]) = 0bin0);
-ASSERT((X[0bin000100000000] & Y[0bin000100000000]) = 0bin0);
-ASSERT((X[0bin000100000001] & Y[0bin000100000001]) = 0bin0);
-ASSERT((X[0bin000100000010] & Y[0bin000100000010]) = 0bin0);
-ASSERT((X[0bin000100000011] & Y[0bin000100000011]) = 0bin0);
-ASSERT((X[0bin000100000100] & Y[0bin000100000100]) = 0bin0);
-ASSERT((X[0bin000100000101] & Y[0bin000100000101]) = 0bin0);
-ASSERT((X[0bin000100000110] & Y[0bin000100000110]) = 0bin0);
-ASSERT((X[0bin000100000111] & Y[0bin000100000111]) = 0bin0);
-ASSERT((X[0bin000100001000] & Y[0bin000100001000]) = 0bin0);
-ASSERT((X[0bin000100001001] & Y[0bin000100001001]) = 0bin0);
-ASSERT((X[0bin000100001010] & Y[0bin000100001010]) = 0bin0);
-ASSERT((X[0bin000100001011] & Y[0bin000100001011]) = 0bin0);
-ASSERT((X[0bin000100001100] & Y[0bin000100001100]) = 0bin0);
-ASSERT((X[0bin000100001101] & Y[0bin000100001101]) = 0bin0);
-ASSERT((X[0bin000100001110] & Y[0bin000100001110]) = 0bin0);
-ASSERT((X[0bin000100001111] & Y[0bin000100001111]) = 0bin0);
-ASSERT((X[0bin000100010000] & Y[0bin000100010000]) = 0bin0);
-ASSERT((X[0bin000100010001] & Y[0bin000100010001]) = 0bin0);
-ASSERT((X[0bin000100010010] & Y[0bin000100010010]) = 0bin0);
-ASSERT((X[0bin000100010011] & Y[0bin000100010011]) = 0bin0);
-ASSERT((X[0bin000100010100] & Y[0bin000100010100]) = 0bin0);
-ASSERT((X[0bin000100010101] & Y[0bin000100010101]) = 0bin0);
-ASSERT((X[0bin000100010110] & Y[0bin000100010110]) = 0bin0);
-ASSERT((X[0bin000100010111] & Y[0bin000100010111]) = 0bin0);
-ASSERT((X[0bin000100011000] & Y[0bin000100011000]) = 0bin0);
-ASSERT((X[0bin000100011001] & Y[0bin000100011001]) = 0bin0);
-ASSERT((X[0bin000100011011] & Y[0bin000100011011]) = 0bin0);
-ASSERT((X[0bin000100011100] & Y[0bin000100011100]) = 0bin0);
-ASSERT((X[0bin000100011101] & Y[0bin000100011101]) = 0bin0);
-ASSERT((X[0bin000100011110] & Y[0bin000100011110]) = 0bin0);
-ASSERT((X[0bin000100011111] & Y[0bin000100011111]) = 0bin0);
-ASSERT((X[0bin000100100000] & Y[0bin000100100000]) = 0bin0);
-ASSERT((X[0bin000100100001] & Y[0bin000100100001]) = 0bin0);
-ASSERT((X[0bin000100100010] & Y[0bin000100100010]) = 0bin0);
-ASSERT((X[0bin000100100011] & Y[0bin000100100011]) = 0bin0);
-ASSERT((X[0bin000100100100] & Y[0bin000100100100]) = 0bin0);
-ASSERT((X[0bin000100100101] & Y[0bin000100100101]) = 0bin0);
-ASSERT((X[0bin000100100110] & Y[0bin000100100110]) = 0bin0);
-ASSERT((X[0bin000100100111] & Y[0bin000100100111]) = 0bin0);
-ASSERT((X[0bin000100101000] & Y[0bin000100101000]) = 0bin0);
-ASSERT((X[0bin000100101001] & Y[0bin000100101001]) = 0bin0);
-ASSERT((X[0bin000100101010] & Y[0bin000100101010]) = 0bin0);
-ASSERT((X[0bin000100101011] & Y[0bin000100101011]) = 0bin0);
-ASSERT((X[0bin000100101100] & Y[0bin000100101100]) = 0bin0);
-ASSERT((X[0bin000100101101] & Y[0bin000100101101]) = 0bin0);
-ASSERT((X[0bin000100101110] & Y[0bin000100101110]) = 0bin0);
-ASSERT((X[0bin000100101111] & Y[0bin000100101111]) = 0bin0);
-ASSERT((X[0bin000100110000] & Y[0bin000100110000]) = 0bin0);
-ASSERT((X[0bin000100110001] & Y[0bin000100110001]) = 0bin0);
-ASSERT((X[0bin000100110010] & Y[0bin000100110010]) = 0bin0);
-ASSERT((X[0bin000100110011] & Y[0bin000100110011]) = 0bin0);
-ASSERT((X[0bin000100110100] & Y[0bin000100110100]) = 0bin0);
-ASSERT((X[0bin000100110101] & Y[0bin000100110101]) = 0bin0);
-ASSERT((X[0bin000100110110] & Y[0bin000100110110]) = 0bin0);
-ASSERT((X[0bin000100110111] & Y[0bin000100110111]) = 0bin0);
-ASSERT((X[0bin000100111000] & Y[0bin000100111000]) = 0bin0);
-ASSERT((X[0bin000100111001] & Y[0bin000100111001]) = 0bin0);
-ASSERT((X[0bin000100111010] & Y[0bin000100111010]) = 0bin0);
-ASSERT((X[0bin000100111011] & Y[0bin000100111011]) = 0bin0);
-ASSERT((X[0bin000100111100] & Y[0bin000100111100]) = 0bin0);
-ASSERT((X[0bin000100111101] & Y[0bin000100111101]) = 0bin0);
-ASSERT((X[0bin000100111110] & Y[0bin000100111110]) = 0bin0);
-ASSERT((X[0bin000100111111] & Y[0bin000100111111]) = 0bin0);
-ASSERT((X[0bin000101000000] & Y[0bin000101000000]) = 0bin0);
-ASSERT((X[0bin000101000001] & Y[0bin000101000001]) = 0bin0);
-ASSERT((X[0bin000101000010] & Y[0bin000101000010]) = 0bin0);
-ASSERT((X[0bin000101000011] & Y[0bin000101000011]) = 0bin0);
-ASSERT((X[0bin000101000100] & Y[0bin000101000100]) = 0bin0);
-ASSERT((X[0bin000101000101] & Y[0bin000101000101]) = 0bin0);
-ASSERT((X[0bin000101000110] & Y[0bin000101000110]) = 0bin0);
-ASSERT((X[0bin000101000111] & Y[0bin000101000111]) = 0bin0);
-ASSERT((X[0bin000101001000] & Y[0bin000101001000]) = 0bin0);
-ASSERT((X[0bin000101001010] & Y[0bin000101001010]) = 0bin0);
-ASSERT((X[0bin000101001011] & Y[0bin000101001011]) = 0bin0);
-ASSERT((X[0bin000101001100] & Y[0bin000101001100]) = 0bin0);
-ASSERT((X[0bin000101001101] & Y[0bin000101001101]) = 0bin0);
-ASSERT((X[0bin000101001110] & Y[0bin000101001110]) = 0bin0);
-ASSERT((X[0bin000101001111] & Y[0bin000101001111]) = 0bin0);
-ASSERT((X[0bin000101010000] & Y[0bin000101010000]) = 0bin0);
-ASSERT((X[0bin000101010001] & Y[0bin000101010001]) = 0bin0);
-ASSERT((X[0bin000101010010] & Y[0bin000101010010]) = 0bin0);
-ASSERT((X[0bin000101010011] & Y[0bin000101010011]) = 0bin0);
-ASSERT((X[0bin000101010100] & Y[0bin000101010100]) = 0bin0);
-ASSERT((X[0bin000101010101] & Y[0bin000101010101]) = 0bin0);
-ASSERT((X[0bin000101010110] & Y[0bin000101010110]) = 0bin0);
-ASSERT((X[0bin000101010111] & Y[0bin000101010111]) = 0bin0);
-ASSERT((X[0bin000101011000] & Y[0bin000101011000]) = 0bin0);
-ASSERT((X[0bin000101011001] & Y[0bin000101011001]) = 0bin0);
-ASSERT((X[0bin000101011010] & Y[0bin000101011010]) = 0bin0);
-ASSERT((X[0bin000101011011] & Y[0bin000101011011]) = 0bin0);
-ASSERT((X[0bin000101011100] & Y[0bin000101011100]) = 0bin0);
-ASSERT((X[0bin000101011101] & Y[0bin000101011101]) = 0bin0);
-ASSERT((X[0bin000101011110] & Y[0bin000101011110]) = 0bin0);
-ASSERT((X[0bin000101011111] & Y[0bin000101011111]) = 0bin0);
-ASSERT((X[0bin000101100000] & Y[0bin000101100000]) = 0bin0);
-ASSERT((X[0bin000101100001] & Y[0bin000101100001]) = 0bin0);
-ASSERT((X[0bin000101100010] & Y[0bin000101100010]) = 0bin0);
-ASSERT((X[0bin000101100011] & Y[0bin000101100011]) = 0bin0);
-ASSERT((X[0bin000101100100] & Y[0bin000101100100]) = 0bin0);
-ASSERT((X[0bin000101100101] & Y[0bin000101100101]) = 0bin0);
-ASSERT((X[0bin000101100110] & Y[0bin000101100110]) = 0bin0);
-ASSERT((X[0bin000101100111] & Y[0bin000101100111]) = 0bin0);
-ASSERT((X[0bin000101101000] & Y[0bin000101101000]) = 0bin0);
-ASSERT((X[0bin000101101001] & Y[0bin000101101001]) = 0bin0);
-ASSERT((X[0bin000101101010] & Y[0bin000101101010]) = 0bin0);
-ASSERT((X[0bin000101101011] & Y[0bin000101101011]) = 0bin0);
-ASSERT((X[0bin000101101100] & Y[0bin000101101100]) = 0bin0);
-ASSERT((X[0bin000101101101] & Y[0bin000101101101]) = 0bin0);
-ASSERT((X[0bin000101101110] & Y[0bin000101101110]) = 0bin0);
-ASSERT((X[0bin000101101111] & Y[0bin000101101111]) = 0bin0);
-ASSERT((X[0bin000101110000] & Y[0bin000101110000]) = 0bin0);
-ASSERT((X[0bin000101110001] & Y[0bin000101110001]) = 0bin0);
-ASSERT((X[0bin000101110010] & Y[0bin000101110010]) = 0bin0);
-ASSERT((X[0bin000101110011] & Y[0bin000101110011]) = 0bin0);
-ASSERT((X[0bin000101110100] & Y[0bin000101110100]) = 0bin0);
-ASSERT((X[0bin000101110101] & Y[0bin000101110101]) = 0bin0);
-ASSERT((X[0bin000101110110] & Y[0bin000101110110]) = 0bin0);
-ASSERT((X[0bin000101110111] & Y[0bin000101110111]) = 0bin0);
-ASSERT((X[0bin000101111001] & Y[0bin000101111001]) = 0bin0);
-ASSERT((X[0bin000101111010] & Y[0bin000101111010]) = 0bin0);
-ASSERT((X[0bin000101111011] & Y[0bin000101111011]) = 0bin0);
-ASSERT((X[0bin000101111100] & Y[0bin000101111100]) = 0bin0);
-ASSERT((X[0bin000101111101] & Y[0bin000101111101]) = 0bin0);
-ASSERT((X[0bin000101111110] & Y[0bin000101111110]) = 0bin0);
-ASSERT((X[0bin000101111111] & Y[0bin000101111111]) = 0bin0);
-ASSERT((X[0bin000110000000] & Y[0bin000110000000]) = 0bin0);
-ASSERT((X[0bin000110000001] & Y[0bin000110000001]) = 0bin0);
-ASSERT((X[0bin000110000010] & Y[0bin000110000010]) = 0bin0);
-ASSERT((X[0bin000110000011] & Y[0bin000110000011]) = 0bin0);
-ASSERT((X[0bin000110000100] & Y[0bin000110000100]) = 0bin0);
-ASSERT((X[0bin000110000101] & Y[0bin000110000101]) = 0bin0);
-ASSERT((X[0bin000110000110] & Y[0bin000110000110]) = 0bin0);
-ASSERT((X[0bin000110000111] & Y[0bin000110000111]) = 0bin0);
-ASSERT((X[0bin000110001000] & Y[0bin000110001000]) = 0bin0);
-ASSERT((X[0bin000110001001] & Y[0bin000110001001]) = 0bin0);
-ASSERT((X[0bin000110001010] & Y[0bin000110001010]) = 0bin0);
-ASSERT((X[0bin000110001011] & Y[0bin000110001011]) = 0bin0);
-ASSERT((X[0bin000110001100] & Y[0bin000110001100]) = 0bin0);
-ASSERT((X[0bin000110001101] & Y[0bin000110001101]) = 0bin0);
-ASSERT((X[0bin000110001110] & Y[0bin000110001110]) = 0bin0);
-ASSERT((X[0bin000110001111] & Y[0bin000110001111]) = 0bin0);
-ASSERT((X[0bin000110010000] & Y[0bin000110010000]) = 0bin0);
-ASSERT((X[0bin000110010001] & Y[0bin000110010001]) = 0bin0);
-ASSERT((X[0bin000110010010] & Y[0bin000110010010]) = 0bin0);
-ASSERT((X[0bin000110010011] & Y[0bin000110010011]) = 0bin0);
-ASSERT((X[0bin000110010100] & Y[0bin000110010100]) = 0bin0);
-ASSERT((X[0bin000110010101] & Y[0bin000110010101]) = 0bin0);
-ASSERT((X[0bin000110010110] & Y[0bin000110010110]) = 0bin0);
-ASSERT((X[0bin000110010111] & Y[0bin000110010111]) = 0bin0);
-ASSERT((X[0bin000110011000] & Y[0bin000110011000]) = 0bin0);
-ASSERT((X[0bin000110011001] & Y[0bin000110011001]) = 0bin0);
-ASSERT((X[0bin000110011010] & Y[0bin000110011010]) = 0bin0);
-ASSERT((X[0bin000110011011] & Y[0bin000110011011]) = 0bin0);
-ASSERT((X[0bin000110011100] & Y[0bin000110011100]) = 0bin0);
-ASSERT((X[0bin000110011101] & Y[0bin000110011101]) = 0bin0);
-ASSERT((X[0bin000110011110] & Y[0bin000110011110]) = 0bin0);
-ASSERT((X[0bin000110011111] & Y[0bin000110011111]) = 0bin0);
-ASSERT((X[0bin000110100000] & Y[0bin000110100000]) = 0bin0);
-ASSERT((X[0bin000110100001] & Y[0bin000110100001]) = 0bin0);
-ASSERT((X[0bin000110100010] & Y[0bin000110100010]) = 0bin0);
-ASSERT((X[0bin000110100011] & Y[0bin000110100011]) = 0bin0);
-ASSERT((X[0bin000110100100] & Y[0bin000110100100]) = 0bin0);
-ASSERT((X[0bin000110100101] & Y[0bin000110100101]) = 0bin0);
-ASSERT((X[0bin000110100110] & Y[0bin000110100110]) = 0bin0);
-ASSERT((X[0bin000110101000] & Y[0bin000110101000]) = 0bin0);
-ASSERT((X[0bin000110101001] & Y[0bin000110101001]) = 0bin0);
-ASSERT((X[0bin000110101010] & Y[0bin000110101010]) = 0bin0);
-ASSERT((X[0bin000110101011] & Y[0bin000110101011]) = 0bin0);
-ASSERT((X[0bin000110101100] & Y[0bin000110101100]) = 0bin0);
-ASSERT((X[0bin000110101101] & Y[0bin000110101101]) = 0bin0);
-ASSERT((X[0bin000110101110] & Y[0bin000110101110]) = 0bin0);
-ASSERT((X[0bin000110101111] & Y[0bin000110101111]) = 0bin0);
-ASSERT((X[0bin000110110000] & Y[0bin000110110000]) = 0bin0);
-ASSERT((X[0bin000110110001] & Y[0bin000110110001]) = 0bin0);
-ASSERT((X[0bin000110110010] & Y[0bin000110110010]) = 0bin0);
-ASSERT((X[0bin000110110011] & Y[0bin000110110011]) = 0bin0);
-ASSERT((X[0bin000110110100] & Y[0bin000110110100]) = 0bin0);
-ASSERT((X[0bin000110110101] & Y[0bin000110110101]) = 0bin0);
-ASSERT((X[0bin000110110110] & Y[0bin000110110110]) = 0bin0);
-ASSERT((X[0bin000110110111] & Y[0bin000110110111]) = 0bin0);
-ASSERT((X[0bin000110111000] & Y[0bin000110111000]) = 0bin0);
-ASSERT((X[0bin000110111001] & Y[0bin000110111001]) = 0bin0);
-ASSERT((X[0bin000110111010] & Y[0bin000110111010]) = 0bin0);
-ASSERT((X[0bin000110111011] & Y[0bin000110111011]) = 0bin0);
-ASSERT((X[0bin000110111100] & Y[0bin000110111100]) = 0bin0);
-ASSERT((X[0bin000110111101] & Y[0bin000110111101]) = 0bin0);
-ASSERT((X[0bin000110111110] & Y[0bin000110111110]) = 0bin0);
-ASSERT((X[0bin000110111111] & Y[0bin000110111111]) = 0bin0);
-ASSERT((X[0bin000111000000] & Y[0bin000111000000]) = 0bin0);
-ASSERT((X[0bin000111000001] & Y[0bin000111000001]) = 0bin0);
-ASSERT((X[0bin000111000010] & Y[0bin000111000010]) = 0bin0);
-ASSERT((X[0bin000111000011] & Y[0bin000111000011]) = 0bin0);
-ASSERT((X[0bin000111000100] & Y[0bin000111000100]) = 0bin0);
-ASSERT((X[0bin000111000101] & Y[0bin000111000101]) = 0bin0);
-ASSERT((X[0bin000111000110] & Y[0bin000111000110]) = 0bin0);
-ASSERT((X[0bin000111000111] & Y[0bin000111000111]) = 0bin0);
-ASSERT((X[0bin000111001000] & Y[0bin000111001000]) = 0bin0);
-ASSERT((X[0bin000111001001] & Y[0bin000111001001]) = 0bin0);
-ASSERT((X[0bin000111001010] & Y[0bin000111001010]) = 0bin0);
-ASSERT((X[0bin000111001011] & Y[0bin000111001011]) = 0bin0);
-ASSERT((X[0bin000111001100] & Y[0bin000111001100]) = 0bin0);
-ASSERT((X[0bin000111001101] & Y[0bin000111001101]) = 0bin0);
-ASSERT((X[0bin000111001110] & Y[0bin000111001110]) = 0bin0);
-ASSERT((X[0bin000111001111] & Y[0bin000111001111]) = 0bin0);
-ASSERT((X[0bin000111010000] & Y[0bin000111010000]) = 0bin0);
-ASSERT((X[0bin000111010001] & Y[0bin000111010001]) = 0bin0);
-ASSERT((X[0bin000111010010] & Y[0bin000111010010]) = 0bin0);
-ASSERT((X[0bin000111010011] & Y[0bin000111010011]) = 0bin0);
-ASSERT((X[0bin000111010100] & Y[0bin000111010100]) = 0bin0);
-ASSERT((X[0bin000111010101] & Y[0bin000111010101]) = 0bin0);
-ASSERT((X[0bin000111010111] & Y[0bin000111010111]) = 0bin0);
-ASSERT((X[0bin000111011000] & Y[0bin000111011000]) = 0bin0);
-ASSERT((X[0bin000111011001] & Y[0bin000111011001]) = 0bin0);
-ASSERT((X[0bin000111011010] & Y[0bin000111011010]) = 0bin0);
-ASSERT((X[0bin000111011011] & Y[0bin000111011011]) = 0bin0);
-ASSERT((X[0bin000111011100] & Y[0bin000111011100]) = 0bin0);
-ASSERT((X[0bin000111011101] & Y[0bin000111011101]) = 0bin0);
-ASSERT((X[0bin000111011110] & Y[0bin000111011110]) = 0bin0);
-ASSERT((X[0bin000111011111] & Y[0bin000111011111]) = 0bin0);
-ASSERT((X[0bin000111100000] & Y[0bin000111100000]) = 0bin0);
-ASSERT((X[0bin000111100001] & Y[0bin000111100001]) = 0bin0);
-ASSERT((X[0bin000111100010] & Y[0bin000111100010]) = 0bin0);
-ASSERT((X[0bin000111100011] & Y[0bin000111100011]) = 0bin0);
-ASSERT((X[0bin000111100100] & Y[0bin000111100100]) = 0bin0);
-ASSERT((X[0bin000111100101] & Y[0bin000111100101]) = 0bin0);
-ASSERT((X[0bin000111100110] & Y[0bin000111100110]) = 0bin0);
-ASSERT((X[0bin000111100111] & Y[0bin000111100111]) = 0bin0);
-ASSERT((X[0bin000111101000] & Y[0bin000111101000]) = 0bin0);
-ASSERT((X[0bin000111101001] & Y[0bin000111101001]) = 0bin0);
-ASSERT((X[0bin000111101010] & Y[0bin000111101010]) = 0bin0);
-ASSERT((X[0bin000111101011] & Y[0bin000111101011]) = 0bin0);
-ASSERT((X[0bin000111101100] & Y[0bin000111101100]) = 0bin0);
-ASSERT((X[0bin000111101101] & Y[0bin000111101101]) = 0bin0);
-ASSERT((X[0bin000111101110] & Y[0bin000111101110]) = 0bin0);
-ASSERT((X[0bin000111101111] & Y[0bin000111101111]) = 0bin0);
-ASSERT((X[0bin000111110000] & Y[0bin000111110000]) = 0bin0);
-ASSERT((X[0bin000111110001] & Y[0bin000111110001]) = 0bin0);
-ASSERT((X[0bin000111110010] & Y[0bin000111110010]) = 0bin0);
-ASSERT((X[0bin000111110011] & Y[0bin000111110011]) = 0bin0);
-ASSERT((X[0bin000111110100] & Y[0bin000111110100]) = 0bin0);
-ASSERT((X[0bin000111110101] & Y[0bin000111110101]) = 0bin0);
-ASSERT((X[0bin000111110110] & Y[0bin000111110110]) = 0bin0);
-ASSERT((X[0bin000111110111] & Y[0bin000111110111]) = 0bin0);
-ASSERT((X[0bin000111111000] & Y[0bin000111111000]) = 0bin0);
-ASSERT((X[0bin000111111001] & Y[0bin000111111001]) = 0bin0);
-ASSERT((X[0bin000111111010] & Y[0bin000111111010]) = 0bin0);
-ASSERT((X[0bin000111111011] & Y[0bin000111111011]) = 0bin0);
-ASSERT((X[0bin000111111100] & Y[0bin000111111100]) = 0bin0);
-ASSERT((X[0bin000111111101] & Y[0bin000111111101]) = 0bin0);
-ASSERT((X[0bin000111111110] & Y[0bin000111111110]) = 0bin0);
-ASSERT((X[0bin000111111111] & Y[0bin000111111111]) = 0bin0);
-ASSERT((X[0bin001000000000] & Y[0bin001000000000]) = 0bin0);
-ASSERT((X[0bin001000000001] & Y[0bin001000000001]) = 0bin0);
-ASSERT((X[0bin001000000010] & Y[0bin001000000010]) = 0bin0);
-ASSERT((X[0bin001000000011] & Y[0bin001000000011]) = 0bin0);
-ASSERT((X[0bin001000000100] & Y[0bin001000000100]) = 0bin0);
-ASSERT((X[0bin001000000110] & Y[0bin001000000110]) = 0bin0);
-ASSERT((X[0bin001000000111] & Y[0bin001000000111]) = 0bin0);
-ASSERT((X[0bin001000001000] & Y[0bin001000001000]) = 0bin0);
-ASSERT((X[0bin001000001001] & Y[0bin001000001001]) = 0bin0);
-ASSERT((X[0bin001000001010] & Y[0bin001000001010]) = 0bin0);
-ASSERT((X[0bin001000001011] & Y[0bin001000001011]) = 0bin0);
-ASSERT((X[0bin001000001100] & Y[0bin001000001100]) = 0bin0);
-ASSERT((X[0bin001000001101] & Y[0bin001000001101]) = 0bin0);
-ASSERT((X[0bin001000001110] & Y[0bin001000001110]) = 0bin0);
-ASSERT((X[0bin001000001111] & Y[0bin001000001111]) = 0bin0);
-ASSERT((X[0bin001000010000] & Y[0bin001000010000]) = 0bin0);
-ASSERT((X[0bin001000010001] & Y[0bin001000010001]) = 0bin0);
-ASSERT((X[0bin001000010010] & Y[0bin001000010010]) = 0bin0);
-ASSERT((X[0bin001000010011] & Y[0bin001000010011]) = 0bin0);
-ASSERT((X[0bin001000010100] & Y[0bin001000010100]) = 0bin0);
-ASSERT((X[0bin001000010101] & Y[0bin001000010101]) = 0bin0);
-ASSERT((X[0bin001000010110] & Y[0bin001000010110]) = 0bin0);
-ASSERT((X[0bin001000010111] & Y[0bin001000010111]) = 0bin0);
-ASSERT((X[0bin001000011000] & Y[0bin001000011000]) = 0bin0);
-ASSERT((X[0bin001000011001] & Y[0bin001000011001]) = 0bin0);
-ASSERT((X[0bin001000011010] & Y[0bin001000011010]) = 0bin0);
-ASSERT((X[0bin001000011011] & Y[0bin001000011011]) = 0bin0);
-ASSERT((X[0bin001000011100] & Y[0bin001000011100]) = 0bin0);
-ASSERT((X[0bin001000011101] & Y[0bin001000011101]) = 0bin0);
-ASSERT((X[0bin001000011110] & Y[0bin001000011110]) = 0bin0);
-ASSERT((X[0bin001000011111] & Y[0bin001000011111]) = 0bin0);
-ASSERT((X[0bin001000100000] & Y[0bin001000100000]) = 0bin0);
-ASSERT((X[0bin001000100001] & Y[0bin001000100001]) = 0bin0);
-ASSERT((X[0bin001000100010] & Y[0bin001000100010]) = 0bin0);
-ASSERT((X[0bin001000100011] & Y[0bin001000100011]) = 0bin0);
-ASSERT((X[0bin001000100100] & Y[0bin001000100100]) = 0bin0);
-ASSERT((X[0bin001000100101] & Y[0bin001000100101]) = 0bin0);
-ASSERT((X[0bin001000100110] & Y[0bin001000100110]) = 0bin0);
-ASSERT((X[0bin001000100111] & Y[0bin001000100111]) = 0bin0);
-ASSERT((X[0bin001000101000] & Y[0bin001000101000]) = 0bin0);
-ASSERT((X[0bin001000101001] & Y[0bin001000101001]) = 0bin0);
-ASSERT((X[0bin001000101010] & Y[0bin001000101010]) = 0bin0);
-ASSERT((X[0bin001000101011] & Y[0bin001000101011]) = 0bin0);
-ASSERT((X[0bin001000101100] & Y[0bin001000101100]) = 0bin0);
-ASSERT((X[0bin001000101101] & Y[0bin001000101101]) = 0bin0);
-ASSERT((X[0bin001000101110] & Y[0bin001000101110]) = 0bin0);
-ASSERT((X[0bin001000101111] & Y[0bin001000101111]) = 0bin0);
-ASSERT((X[0bin001000110000] & Y[0bin001000110000]) = 0bin0);
-ASSERT((X[0bin001000110001] & Y[0bin001000110001]) = 0bin0);
-ASSERT((X[0bin001000110010] & Y[0bin001000110010]) = 0bin0);
-ASSERT((X[0bin001000110011] & Y[0bin001000110011]) = 0bin0);
-ASSERT((X[0bin001000110101] & Y[0bin001000110101]) = 0bin0);
-ASSERT((X[0bin001000110110] & Y[0bin001000110110]) = 0bin0);
-ASSERT((X[0bin001000110111] & Y[0bin001000110111]) = 0bin0);
-ASSERT((X[0bin001000111000] & Y[0bin001000111000]) = 0bin0);
-ASSERT((X[0bin001000111001] & Y[0bin001000111001]) = 0bin0);
-ASSERT((X[0bin001000111010] & Y[0bin001000111010]) = 0bin0);
-ASSERT((X[0bin001000111011] & Y[0bin001000111011]) = 0bin0);
-ASSERT((X[0bin001000111100] & Y[0bin001000111100]) = 0bin0);
-ASSERT((X[0bin001000111101] & Y[0bin001000111101]) = 0bin0);
-ASSERT((X[0bin001000111110] & Y[0bin001000111110]) = 0bin0);
-ASSERT((X[0bin001000111111] & Y[0bin001000111111]) = 0bin0);
-ASSERT((X[0bin001001000000] & Y[0bin001001000000]) = 0bin0);
-ASSERT((X[0bin001001000001] & Y[0bin001001000001]) = 0bin0);
-ASSERT((X[0bin001001000010] & Y[0bin001001000010]) = 0bin0);
-ASSERT((X[0bin001001000011] & Y[0bin001001000011]) = 0bin0);
-ASSERT((X[0bin001001000100] & Y[0bin001001000100]) = 0bin0);
-ASSERT((X[0bin001001000101] & Y[0bin001001000101]) = 0bin0);
-ASSERT((X[0bin001001000110] & Y[0bin001001000110]) = 0bin0);
-ASSERT((X[0bin001001000111] & Y[0bin001001000111]) = 0bin0);
-ASSERT((X[0bin001001001000] & Y[0bin001001001000]) = 0bin0);
-ASSERT((X[0bin001001001001] & Y[0bin001001001001]) = 0bin0);
-ASSERT((X[0bin001001001010] & Y[0bin001001001010]) = 0bin0);
-ASSERT((X[0bin001001001011] & Y[0bin001001001011]) = 0bin0);
-ASSERT((X[0bin001001001100] & Y[0bin001001001100]) = 0bin0);
-ASSERT((X[0bin001001001101] & Y[0bin001001001101]) = 0bin0);
-ASSERT((X[0bin001001001110] & Y[0bin001001001110]) = 0bin0);
-ASSERT((X[0bin001001001111] & Y[0bin001001001111]) = 0bin0);
-ASSERT((X[0bin001001010000] & Y[0bin001001010000]) = 0bin0);
-ASSERT((X[0bin001001010001] & Y[0bin001001010001]) = 0bin0);
-ASSERT((X[0bin001001010010] & Y[0bin001001010010]) = 0bin0);
-ASSERT((X[0bin001001010011] & Y[0bin001001010011]) = 0bin0);
-ASSERT((X[0bin001001010100] & Y[0bin001001010100]) = 0bin0);
-ASSERT((X[0bin001001010101] & Y[0bin001001010101]) = 0bin0);
-ASSERT((X[0bin001001010110] & Y[0bin001001010110]) = 0bin0);
-ASSERT((X[0bin001001010111] & Y[0bin001001010111]) = 0bin0);
-ASSERT((X[0bin001001011000] & Y[0bin001001011000]) = 0bin0);
-ASSERT((X[0bin001001011001] & Y[0bin001001011001]) = 0bin0);
-ASSERT((X[0bin001001011010] & Y[0bin001001011010]) = 0bin0);
-ASSERT((X[0bin001001011011] & Y[0bin001001011011]) = 0bin0);
-ASSERT((X[0bin001001011100] & Y[0bin001001011100]) = 0bin0);
-ASSERT((X[0bin001001011101] & Y[0bin001001011101]) = 0bin0);
-ASSERT((X[0bin001001011110] & Y[0bin001001011110]) = 0bin0);
-ASSERT((X[0bin001001011111] & Y[0bin001001011111]) = 0bin0);
-ASSERT((X[0bin001001100000] & Y[0bin001001100000]) = 0bin0);
-ASSERT((X[0bin001001100001] & Y[0bin001001100001]) = 0bin0);
-ASSERT((X[0bin001001100010] & Y[0bin001001100010]) = 0bin0);
-ASSERT((X[0bin001001100100] & Y[0bin001001100100]) = 0bin0);
-ASSERT((X[0bin001001100101] & Y[0bin001001100101]) = 0bin0);
-ASSERT((X[0bin001001100110] & Y[0bin001001100110]) = 0bin0);
-ASSERT((X[0bin001001100111] & Y[0bin001001100111]) = 0bin0);
-ASSERT((X[0bin001001101000] & Y[0bin001001101000]) = 0bin0);
-ASSERT((X[0bin001001101001] & Y[0bin001001101001]) = 0bin0);
-ASSERT((X[0bin001001101010] & Y[0bin001001101010]) = 0bin0);
-ASSERT((X[0bin001001101011] & Y[0bin001001101011]) = 0bin0);
-ASSERT((X[0bin001001101100] & Y[0bin001001101100]) = 0bin0);
-ASSERT((X[0bin001001101101] & Y[0bin001001101101]) = 0bin0);
-ASSERT((X[0bin001001101110] & Y[0bin001001101110]) = 0bin0);
-ASSERT((X[0bin001001101111] & Y[0bin001001101111]) = 0bin0);
-ASSERT((X[0bin001001110000] & Y[0bin001001110000]) = 0bin0);
-ASSERT((X[0bin001001110001] & Y[0bin001001110001]) = 0bin0);
-ASSERT((X[0bin001001110010] & Y[0bin001001110010]) = 0bin0);
-ASSERT((X[0bin001001110011] & Y[0bin001001110011]) = 0bin0);
-ASSERT((X[0bin001001110100] & Y[0bin001001110100]) = 0bin0);
-ASSERT((X[0bin001001110101] & Y[0bin001001110101]) = 0bin0);
-ASSERT((X[0bin001001110110] & Y[0bin001001110110]) = 0bin0);
-ASSERT((X[0bin001001110111] & Y[0bin001001110111]) = 0bin0);
-ASSERT((X[0bin001001111000] & Y[0bin001001111000]) = 0bin0);
-ASSERT((X[0bin001001111001] & Y[0bin001001111001]) = 0bin0);
-ASSERT((X[0bin001001111010] & Y[0bin001001111010]) = 0bin0);
-ASSERT((X[0bin001001111011] & Y[0bin001001111011]) = 0bin0);
-ASSERT((X[0bin001001111100] & Y[0bin001001111100]) = 0bin0);
-ASSERT((X[0bin001001111101] & Y[0bin001001111101]) = 0bin0);
-ASSERT((X[0bin001001111110] & Y[0bin001001111110]) = 0bin0);
-ASSERT((X[0bin001001111111] & Y[0bin001001111111]) = 0bin0);
-ASSERT((X[0bin001010000000] & Y[0bin001010000000]) = 0bin0);
-ASSERT((X[0bin001010000001] & Y[0bin001010000001]) = 0bin0);
-ASSERT((X[0bin001010000010] & Y[0bin001010000010]) = 0bin0);
-ASSERT((X[0bin001010000011] & Y[0bin001010000011]) = 0bin0);
-ASSERT((X[0bin001010000100] & Y[0bin001010000100]) = 0bin0);
-ASSERT((X[0bin001010000101] & Y[0bin001010000101]) = 0bin0);
-ASSERT((X[0bin001010000110] & Y[0bin001010000110]) = 0bin0);
-ASSERT((X[0bin001010000111] & Y[0bin001010000111]) = 0bin0);
-ASSERT((X[0bin001010001000] & Y[0bin001010001000]) = 0bin0);
-ASSERT((X[0bin001010001001] & Y[0bin001010001001]) = 0bin0);
-ASSERT((X[0bin001010001010] & Y[0bin001010001010]) = 0bin0);
-ASSERT((X[0bin001010001011] & Y[0bin001010001011]) = 0bin0);
-ASSERT((X[0bin001010001100] & Y[0bin001010001100]) = 0bin0);
-ASSERT((X[0bin001010001101] & Y[0bin001010001101]) = 0bin0);
-ASSERT((X[0bin001010001110] & Y[0bin001010001110]) = 0bin0);
-ASSERT((X[0bin001010001111] & Y[0bin001010001111]) = 0bin0);
-ASSERT((X[0bin001010010000] & Y[0bin001010010000]) = 0bin0);
-ASSERT((X[0bin001010010001] & Y[0bin001010010001]) = 0bin0);
-ASSERT((X[0bin001010010011] & Y[0bin001010010011]) = 0bin0);
-ASSERT((X[0bin001010010100] & Y[0bin001010010100]) = 0bin0);
-ASSERT((X[0bin001010010101] & Y[0bin001010010101]) = 0bin0);
-ASSERT((X[0bin001010010110] & Y[0bin001010010110]) = 0bin0);
-ASSERT((X[0bin001010010111] & Y[0bin001010010111]) = 0bin0);
-ASSERT((X[0bin001010011000] & Y[0bin001010011000]) = 0bin0);
-ASSERT((X[0bin001010011001] & Y[0bin001010011001]) = 0bin0);
-ASSERT((X[0bin001010011010] & Y[0bin001010011010]) = 0bin0);
-ASSERT((X[0bin001010011011] & Y[0bin001010011011]) = 0bin0);
-ASSERT((X[0bin001010011100] & Y[0bin001010011100]) = 0bin0);
-ASSERT((X[0bin001010011101] & Y[0bin001010011101]) = 0bin0);
-ASSERT((X[0bin001010011110] & Y[0bin001010011110]) = 0bin0);
-ASSERT((X[0bin001010011111] & Y[0bin001010011111]) = 0bin0);
-ASSERT((X[0bin001010100000] & Y[0bin001010100000]) = 0bin0);
-ASSERT((X[0bin001010100001] & Y[0bin001010100001]) = 0bin0);
-ASSERT((X[0bin001010100010] & Y[0bin001010100010]) = 0bin0);
-ASSERT((X[0bin001010100011] & Y[0bin001010100011]) = 0bin0);
-ASSERT((X[0bin001010100100] & Y[0bin001010100100]) = 0bin0);
-ASSERT((X[0bin001010100101] & Y[0bin001010100101]) = 0bin0);
-ASSERT((X[0bin001010100110] & Y[0bin001010100110]) = 0bin0);
-ASSERT((X[0bin001010100111] & Y[0bin001010100111]) = 0bin0);
-ASSERT((X[0bin001010101000] & Y[0bin001010101000]) = 0bin0);
-ASSERT((X[0bin001010101001] & Y[0bin001010101001]) = 0bin0);
-ASSERT((X[0bin001010101010] & Y[0bin001010101010]) = 0bin0);
-ASSERT((X[0bin001010101011] & Y[0bin001010101011]) = 0bin0);
-ASSERT((X[0bin001010101100] & Y[0bin001010101100]) = 0bin0);
-ASSERT((X[0bin001010101101] & Y[0bin001010101101]) = 0bin0);
-ASSERT((X[0bin001010101110] & Y[0bin001010101110]) = 0bin0);
-ASSERT((X[0bin001010101111] & Y[0bin001010101111]) = 0bin0);
-ASSERT((X[0bin001010110000] & Y[0bin001010110000]) = 0bin0);
-ASSERT((X[0bin001010110001] & Y[0bin001010110001]) = 0bin0);
-ASSERT((X[0bin001010110010] & Y[0bin001010110010]) = 0bin0);
-ASSERT((X[0bin001010110011] & Y[0bin001010110011]) = 0bin0);
-ASSERT((X[0bin001010110100] & Y[0bin001010110100]) = 0bin0);
-ASSERT((X[0bin001010110101] & Y[0bin001010110101]) = 0bin0);
-ASSERT((X[0bin001010110110] & Y[0bin001010110110]) = 0bin0);
-ASSERT((X[0bin001010110111] & Y[0bin001010110111]) = 0bin0);
-ASSERT((X[0bin001010111000] & Y[0bin001010111000]) = 0bin0);
-ASSERT((X[0bin001010111001] & Y[0bin001010111001]) = 0bin0);
-ASSERT((X[0bin001010111010] & Y[0bin001010111010]) = 0bin0);
-ASSERT((X[0bin001010111011] & Y[0bin001010111011]) = 0bin0);
-ASSERT((X[0bin001010111100] & Y[0bin001010111100]) = 0bin0);
-ASSERT((X[0bin001010111101] & Y[0bin001010111101]) = 0bin0);
-ASSERT((X[0bin001010111110] & Y[0bin001010111110]) = 0bin0);
-ASSERT((X[0bin001010111111] & Y[0bin001010111111]) = 0bin0);
-ASSERT((X[0bin001011000000] & Y[0bin001011000000]) = 0bin0);
-ASSERT((X[0bin001011000010] & Y[0bin001011000010]) = 0bin0);
-ASSERT((X[0bin001011000011] & Y[0bin001011000011]) = 0bin0);
-ASSERT((X[0bin001011000100] & Y[0bin001011000100]) = 0bin0);
-ASSERT((X[0bin001011000101] & Y[0bin001011000101]) = 0bin0);
-ASSERT((X[0bin001011000110] & Y[0bin001011000110]) = 0bin0);
-ASSERT((X[0bin001011000111] & Y[0bin001011000111]) = 0bin0);
-ASSERT((X[0bin001011001000] & Y[0bin001011001000]) = 0bin0);
-ASSERT((X[0bin001011001001] & Y[0bin001011001001]) = 0bin0);
-ASSERT((X[0bin001011001010] & Y[0bin001011001010]) = 0bin0);
-ASSERT((X[0bin001011001011] & Y[0bin001011001011]) = 0bin0);
-ASSERT((X[0bin001011001100] & Y[0bin001011001100]) = 0bin0);
-ASSERT((X[0bin001011001101] & Y[0bin001011001101]) = 0bin0);
-ASSERT((X[0bin001011001110] & Y[0bin001011001110]) = 0bin0);
-ASSERT((X[0bin001011001111] & Y[0bin001011001111]) = 0bin0);
-ASSERT((X[0bin001011010000] & Y[0bin001011010000]) = 0bin0);
-ASSERT((X[0bin001011010001] & Y[0bin001011010001]) = 0bin0);
-ASSERT((X[0bin001011010010] & Y[0bin001011010010]) = 0bin0);
-ASSERT((X[0bin001011010011] & Y[0bin001011010011]) = 0bin0);
-ASSERT((X[0bin001011010100] & Y[0bin001011010100]) = 0bin0);
-ASSERT((X[0bin001011010101] & Y[0bin001011010101]) = 0bin0);
-ASSERT((X[0bin001011010110] & Y[0bin001011010110]) = 0bin0);
-ASSERT((X[0bin001011010111] & Y[0bin001011010111]) = 0bin0);
-ASSERT((X[0bin001011011000] & Y[0bin001011011000]) = 0bin0);
-ASSERT((X[0bin001011011001] & Y[0bin001011011001]) = 0bin0);
-ASSERT((X[0bin001011011010] & Y[0bin001011011010]) = 0bin0);
-ASSERT((X[0bin001011011011] & Y[0bin001011011011]) = 0bin0);
-ASSERT((X[0bin001011011100] & Y[0bin001011011100]) = 0bin0);
-ASSERT((X[0bin001011011101] & Y[0bin001011011101]) = 0bin0);
-ASSERT((X[0bin001011011110] & Y[0bin001011011110]) = 0bin0);
-ASSERT((X[0bin001011011111] & Y[0bin001011011111]) = 0bin0);
-ASSERT((X[0bin001011100000] & Y[0bin001011100000]) = 0bin0);
-ASSERT((X[0bin001011100001] & Y[0bin001011100001]) = 0bin0);
-ASSERT((X[0bin001011100010] & Y[0bin001011100010]) = 0bin0);
-ASSERT((X[0bin001011100011] & Y[0bin001011100011]) = 0bin0);
-ASSERT((X[0bin001011100100] & Y[0bin001011100100]) = 0bin0);
-ASSERT((X[0bin001011100101] & Y[0bin001011100101]) = 0bin0);
-ASSERT((X[0bin001011100110] & Y[0bin001011100110]) = 0bin0);
-ASSERT((X[0bin001011100111] & Y[0bin001011100111]) = 0bin0);
-ASSERT((X[0bin001011101000] & Y[0bin001011101000]) = 0bin0);
-ASSERT((X[0bin001011101001] & Y[0bin001011101001]) = 0bin0);
-ASSERT((X[0bin001011101010] & Y[0bin001011101010]) = 0bin0);
-ASSERT((X[0bin001011101011] & Y[0bin001011101011]) = 0bin0);
-ASSERT((X[0bin001011101100] & Y[0bin001011101100]) = 0bin0);
-ASSERT((X[0bin001011101101] & Y[0bin001011101101]) = 0bin0);
-ASSERT((X[0bin001011101110] & Y[0bin001011101110]) = 0bin0);
-ASSERT((X[0bin001011101111] & Y[0bin001011101111]) = 0bin0);
-ASSERT((X[0bin001011110001] & Y[0bin001011110001]) = 0bin0);
-ASSERT((X[0bin001011110010] & Y[0bin001011110010]) = 0bin0);
-ASSERT((X[0bin001011110011] & Y[0bin001011110011]) = 0bin0);
-ASSERT((X[0bin001011110100] & Y[0bin001011110100]) = 0bin0);
-ASSERT((X[0bin001011110101] & Y[0bin001011110101]) = 0bin0);
-ASSERT((X[0bin001011110110] & Y[0bin001011110110]) = 0bin0);
-ASSERT((X[0bin001011110111] & Y[0bin001011110111]) = 0bin0);
-ASSERT((X[0bin001011111000] & Y[0bin001011111000]) = 0bin0);
-ASSERT((X[0bin001011111001] & Y[0bin001011111001]) = 0bin0);
-ASSERT((X[0bin001011111010] & Y[0bin001011111010]) = 0bin0);
-ASSERT((X[0bin001011111011] & Y[0bin001011111011]) = 0bin0);
-ASSERT((X[0bin001011111100] & Y[0bin001011111100]) = 0bin0);
-ASSERT((X[0bin001011111101] & Y[0bin001011111101]) = 0bin0);
-ASSERT((X[0bin001011111110] & Y[0bin001011111110]) = 0bin0);
-ASSERT((X[0bin001011111111] & Y[0bin001011111111]) = 0bin0);
-ASSERT((X[0bin001100000000] & Y[0bin001100000000]) = 0bin0);
-ASSERT((X[0bin001100000001] & Y[0bin001100000001]) = 0bin0);
-ASSERT((X[0bin001100000010] & Y[0bin001100000010]) = 0bin0);
-ASSERT((X[0bin001100000011] & Y[0bin001100000011]) = 0bin0);
-ASSERT((X[0bin001100000100] & Y[0bin001100000100]) = 0bin0);
-ASSERT((X[0bin001100000101] & Y[0bin001100000101]) = 0bin0);
-ASSERT((X[0bin001100000110] & Y[0bin001100000110]) = 0bin0);
-ASSERT((X[0bin001100000111] & Y[0bin001100000111]) = 0bin0);
-ASSERT((X[0bin001100001000] & Y[0bin001100001000]) = 0bin0);
-ASSERT((X[0bin001100001001] & Y[0bin001100001001]) = 0bin0);
-ASSERT((X[0bin001100001010] & Y[0bin001100001010]) = 0bin0);
-ASSERT((X[0bin001100001011] & Y[0bin001100001011]) = 0bin0);
-ASSERT((X[0bin001100001100] & Y[0bin001100001100]) = 0bin0);
-ASSERT((X[0bin001100001101] & Y[0bin001100001101]) = 0bin0);
-ASSERT((X[0bin001100001110] & Y[0bin001100001110]) = 0bin0);
-ASSERT((X[0bin001100001111] & Y[0bin001100001111]) = 0bin0);
-ASSERT((X[0bin001100010000] & Y[0bin001100010000]) = 0bin0);
-ASSERT((X[0bin001100010001] & Y[0bin001100010001]) = 0bin0);
-ASSERT((X[0bin001100010010] & Y[0bin001100010010]) = 0bin0);
-ASSERT((X[0bin001100010011] & Y[0bin001100010011]) = 0bin0);
-ASSERT((X[0bin001100010100] & Y[0bin001100010100]) = 0bin0);
-ASSERT((X[0bin001100010101] & Y[0bin001100010101]) = 0bin0);
-ASSERT((X[0bin001100010110] & Y[0bin001100010110]) = 0bin0);
-ASSERT((X[0bin001100010111] & Y[0bin001100010111]) = 0bin0);
-ASSERT((X[0bin001100011000] & Y[0bin001100011000]) = 0bin0);
-ASSERT((X[0bin001100011001] & Y[0bin001100011001]) = 0bin0);
-ASSERT((X[0bin001100011010] & Y[0bin001100011010]) = 0bin0);
-ASSERT((X[0bin001100011011] & Y[0bin001100011011]) = 0bin0);
-ASSERT((X[0bin001100011100] & Y[0bin001100011100]) = 0bin0);
-ASSERT((X[0bin001100011101] & Y[0bin001100011101]) = 0bin0);
-ASSERT((X[0bin001100011110] & Y[0bin001100011110]) = 0bin0);
-ASSERT((X[0bin001100100000] & Y[0bin001100100000]) = 0bin0);
-ASSERT((X[0bin001100100001] & Y[0bin001100100001]) = 0bin0);
-ASSERT((X[0bin001100100010] & Y[0bin001100100010]) = 0bin0);
-ASSERT((X[0bin001100100011] & Y[0bin001100100011]) = 0bin0);
-ASSERT((X[0bin001100100100] & Y[0bin001100100100]) = 0bin0);
-ASSERT((X[0bin001100100101] & Y[0bin001100100101]) = 0bin0);
-ASSERT((X[0bin001100100110] & Y[0bin001100100110]) = 0bin0);
-ASSERT((X[0bin001100100111] & Y[0bin001100100111]) = 0bin0);
-ASSERT((X[0bin001100101000] & Y[0bin001100101000]) = 0bin0);
-ASSERT((X[0bin001100101001] & Y[0bin001100101001]) = 0bin0);
-ASSERT((X[0bin001100101010] & Y[0bin001100101010]) = 0bin0);
-ASSERT((X[0bin001100101011] & Y[0bin001100101011]) = 0bin0);
-ASSERT((X[0bin001100101100] & Y[0bin001100101100]) = 0bin0);
-ASSERT((X[0bin001100101101] & Y[0bin001100101101]) = 0bin0);
-ASSERT((X[0bin001100101110] & Y[0bin001100101110]) = 0bin0);
-ASSERT((X[0bin001100101111] & Y[0bin001100101111]) = 0bin0);
-ASSERT((X[0bin001100110000] & Y[0bin001100110000]) = 0bin0);
-ASSERT((X[0bin001100110001] & Y[0bin001100110001]) = 0bin0);
-ASSERT((X[0bin001100110010] & Y[0bin001100110010]) = 0bin0);
-ASSERT((X[0bin001100110011] & Y[0bin001100110011]) = 0bin0);
-ASSERT((X[0bin001100110100] & Y[0bin001100110100]) = 0bin0);
-ASSERT((X[0bin001100110101] & Y[0bin001100110101]) = 0bin0);
-ASSERT((X[0bin001100110110] & Y[0bin001100110110]) = 0bin0);
-ASSERT((X[0bin001100110111] & Y[0bin001100110111]) = 0bin0);
-ASSERT((X[0bin001100111000] & Y[0bin001100111000]) = 0bin0);
-ASSERT((X[0bin001100111001] & Y[0bin001100111001]) = 0bin0);
-ASSERT((X[0bin001100111010] & Y[0bin001100111010]) = 0bin0);
-ASSERT((X[0bin001100111011] & Y[0bin001100111011]) = 0bin0);
-ASSERT((X[0bin001100111100] & Y[0bin001100111100]) = 0bin0);
-ASSERT((X[0bin001100111101] & Y[0bin001100111101]) = 0bin0);
-ASSERT((X[0bin001100111110] & Y[0bin001100111110]) = 0bin0);
-ASSERT((X[0bin001100111111] & Y[0bin001100111111]) = 0bin0);
-ASSERT((X[0bin001101000000] & Y[0bin001101000000]) = 0bin0);
-ASSERT((X[0bin001101000001] & Y[0bin001101000001]) = 0bin0);
-ASSERT((X[0bin001101000010] & Y[0bin001101000010]) = 0bin0);
-ASSERT((X[0bin001101000011] & Y[0bin001101000011]) = 0bin0);
-ASSERT((X[0bin001101000100] & Y[0bin001101000100]) = 0bin0);
-ASSERT((X[0bin001101000101] & Y[0bin001101000101]) = 0bin0);
-ASSERT((X[0bin001101000110] & Y[0bin001101000110]) = 0bin0);
-ASSERT((X[0bin001101000111] & Y[0bin001101000111]) = 0bin0);
-ASSERT((X[0bin001101001000] & Y[0bin001101001000]) = 0bin0);
-ASSERT((X[0bin001101001001] & Y[0bin001101001001]) = 0bin0);
-ASSERT((X[0bin001101001010] & Y[0bin001101001010]) = 0bin0);
-ASSERT((X[0bin001101001011] & Y[0bin001101001011]) = 0bin0);
-ASSERT((X[0bin001101001100] & Y[0bin001101001100]) = 0bin0);
-ASSERT((X[0bin001101001101] & Y[0bin001101001101]) = 0bin0);
-ASSERT((X[0bin001101001111] & Y[0bin001101001111]) = 0bin0);
-ASSERT((X[0bin001101010000] & Y[0bin001101010000]) = 0bin0);
-ASSERT((X[0bin001101010001] & Y[0bin001101010001]) = 0bin0);
-ASSERT((X[0bin001101010010] & Y[0bin001101010010]) = 0bin0);
-ASSERT((X[0bin001101010011] & Y[0bin001101010011]) = 0bin0);
-ASSERT((X[0bin001101010100] & Y[0bin001101010100]) = 0bin0);
-ASSERT((X[0bin001101010101] & Y[0bin001101010101]) = 0bin0);
-ASSERT((X[0bin001101010110] & Y[0bin001101010110]) = 0bin0);
-ASSERT((X[0bin001101010111] & Y[0bin001101010111]) = 0bin0);
-ASSERT((X[0bin001101011000] & Y[0bin001101011000]) = 0bin0);
-ASSERT((X[0bin001101011001] & Y[0bin001101011001]) = 0bin0);
-ASSERT((X[0bin001101011010] & Y[0bin001101011010]) = 0bin0);
-ASSERT((X[0bin001101011011] & Y[0bin001101011011]) = 0bin0);
-ASSERT((X[0bin001101011100] & Y[0bin001101011100]) = 0bin0);
-ASSERT((X[0bin001101011101] & Y[0bin001101011101]) = 0bin0);
-ASSERT((X[0bin001101011110] & Y[0bin001101011110]) = 0bin0);
-ASSERT((X[0bin001101011111] & Y[0bin001101011111]) = 0bin0);
-ASSERT((X[0bin001101100000] & Y[0bin001101100000]) = 0bin0);
-ASSERT((X[0bin001101100001] & Y[0bin001101100001]) = 0bin0);
-ASSERT((X[0bin001101100010] & Y[0bin001101100010]) = 0bin0);
-ASSERT((X[0bin001101100011] & Y[0bin001101100011]) = 0bin0);
-ASSERT((X[0bin001101100100] & Y[0bin001101100100]) = 0bin0);
-ASSERT((X[0bin001101100101] & Y[0bin001101100101]) = 0bin0);
-ASSERT((X[0bin001101100110] & Y[0bin001101100110]) = 0bin0);
-ASSERT((X[0bin001101100111] & Y[0bin001101100111]) = 0bin0);
-ASSERT((X[0bin001101101000] & Y[0bin001101101000]) = 0bin0);
-ASSERT((X[0bin001101101001] & Y[0bin001101101001]) = 0bin0);
-ASSERT((X[0bin001101101010] & Y[0bin001101101010]) = 0bin0);
-ASSERT((X[0bin001101101011] & Y[0bin001101101011]) = 0bin0);
-ASSERT((X[0bin001101101100] & Y[0bin001101101100]) = 0bin0);
-ASSERT((X[0bin001101101101] & Y[0bin001101101101]) = 0bin0);
-ASSERT((X[0bin001101101110] & Y[0bin001101101110]) = 0bin0);
-ASSERT((X[0bin001101101111] & Y[0bin001101101111]) = 0bin0);
-ASSERT((X[0bin001101110000] & Y[0bin001101110000]) = 0bin0);
-ASSERT((X[0bin001101110001] & Y[0bin001101110001]) = 0bin0);
-ASSERT((X[0bin001101110010] & Y[0bin001101110010]) = 0bin0);
-ASSERT((X[0bin001101110011] & Y[0bin001101110011]) = 0bin0);
-ASSERT((X[0bin001101110100] & Y[0bin001101110100]) = 0bin0);
-ASSERT((X[0bin001101110101] & Y[0bin001101110101]) = 0bin0);
-ASSERT((X[0bin001101110110] & Y[0bin001101110110]) = 0bin0);
-ASSERT((X[0bin001101110111] & Y[0bin001101110111]) = 0bin0);
-ASSERT((X[0bin001101111000] & Y[0bin001101111000]) = 0bin0);
-ASSERT((X[0bin001101111001] & Y[0bin001101111001]) = 0bin0);
-ASSERT((X[0bin001101111010] & Y[0bin001101111010]) = 0bin0);
-ASSERT((X[0bin001101111011] & Y[0bin001101111011]) = 0bin0);
-ASSERT((X[0bin001101111100] & Y[0bin001101111100]) = 0bin0);
-ASSERT((X[0bin001101111110] & Y[0bin001101111110]) = 0bin0);
-ASSERT((X[0bin001101111111] & Y[0bin001101111111]) = 0bin0);
-ASSERT((X[0bin001110000000] & Y[0bin001110000000]) = 0bin0);
-ASSERT((X[0bin001110000001] & Y[0bin001110000001]) = 0bin0);
-ASSERT((X[0bin001110000010] & Y[0bin001110000010]) = 0bin0);
-ASSERT((X[0bin001110000011] & Y[0bin001110000011]) = 0bin0);
-ASSERT((X[0bin001110000100] & Y[0bin001110000100]) = 0bin0);
-ASSERT((X[0bin001110000101] & Y[0bin001110000101]) = 0bin0);
-ASSERT((X[0bin001110000110] & Y[0bin001110000110]) = 0bin0);
-ASSERT((X[0bin001110000111] & Y[0bin001110000111]) = 0bin0);
-ASSERT((X[0bin001110001000] & Y[0bin001110001000]) = 0bin0);
-ASSERT((X[0bin001110001001] & Y[0bin001110001001]) = 0bin0);
-ASSERT((X[0bin001110001010] & Y[0bin001110001010]) = 0bin0);
-ASSERT((X[0bin001110001011] & Y[0bin001110001011]) = 0bin0);
-ASSERT((X[0bin001110001100] & Y[0bin001110001100]) = 0bin0);
-ASSERT((X[0bin001110001101] & Y[0bin001110001101]) = 0bin0);
-ASSERT((X[0bin001110001110] & Y[0bin001110001110]) = 0bin0);
-ASSERT((X[0bin001110001111] & Y[0bin001110001111]) = 0bin0);
-ASSERT((X[0bin001110010000] & Y[0bin001110010000]) = 0bin0);
-ASSERT((X[0bin001110010001] & Y[0bin001110010001]) = 0bin0);
-ASSERT((X[0bin001110010010] & Y[0bin001110010010]) = 0bin0);
-ASSERT((X[0bin001110010011] & Y[0bin001110010011]) = 0bin0);
-ASSERT((X[0bin001110010100] & Y[0bin001110010100]) = 0bin0);
-ASSERT((X[0bin001110010101] & Y[0bin001110010101]) = 0bin0);
-ASSERT((X[0bin001110010110] & Y[0bin001110010110]) = 0bin0);
-ASSERT((X[0bin001110010111] & Y[0bin001110010111]) = 0bin0);
-ASSERT((X[0bin001110011000] & Y[0bin001110011000]) = 0bin0);
-ASSERT((X[0bin001110011001] & Y[0bin001110011001]) = 0bin0);
-ASSERT((X[0bin001110011010] & Y[0bin001110011010]) = 0bin0);
-ASSERT((X[0bin001110011011] & Y[0bin001110011011]) = 0bin0);
-ASSERT((X[0bin001110011100] & Y[0bin001110011100]) = 0bin0);
-ASSERT((X[0bin001110011101] & Y[0bin001110011101]) = 0bin0);
-ASSERT((X[0bin001110011110] & Y[0bin001110011110]) = 0bin0);
-ASSERT((X[0bin001110011111] & Y[0bin001110011111]) = 0bin0);
-ASSERT((X[0bin001110100000] & Y[0bin001110100000]) = 0bin0);
-ASSERT((X[0bin001110100001] & Y[0bin001110100001]) = 0bin0);
-ASSERT((X[0bin001110100010] & Y[0bin001110100010]) = 0bin0);
-ASSERT((X[0bin001110100011] & Y[0bin001110100011]) = 0bin0);
-ASSERT((X[0bin001110100100] & Y[0bin001110100100]) = 0bin0);
-ASSERT((X[0bin001110100101] & Y[0bin001110100101]) = 0bin0);
-ASSERT((X[0bin001110100110] & Y[0bin001110100110]) = 0bin0);
-ASSERT((X[0bin001110100111] & Y[0bin001110100111]) = 0bin0);
-ASSERT((X[0bin001110101000] & Y[0bin001110101000]) = 0bin0);
-ASSERT((X[0bin001110101001] & Y[0bin001110101001]) = 0bin0);
-ASSERT((X[0bin001110101010] & Y[0bin001110101010]) = 0bin0);
-ASSERT((X[0bin001110101011] & Y[0bin001110101011]) = 0bin0);
-ASSERT((X[0bin001110101101] & Y[0bin001110101101]) = 0bin0);
-ASSERT((X[0bin001110101110] & Y[0bin001110101110]) = 0bin0);
-ASSERT((X[0bin001110101111] & Y[0bin001110101111]) = 0bin0);
-ASSERT((X[0bin001110110000] & Y[0bin001110110000]) = 0bin0);
-ASSERT((X[0bin001110110001] & Y[0bin001110110001]) = 0bin0);
-ASSERT((X[0bin001110110010] & Y[0bin001110110010]) = 0bin0);
-ASSERT((X[0bin001110110011] & Y[0bin001110110011]) = 0bin0);
-ASSERT((X[0bin001110110100] & Y[0bin001110110100]) = 0bin0);
-ASSERT((X[0bin001110110101] & Y[0bin001110110101]) = 0bin0);
-ASSERT((X[0bin001110110110] & Y[0bin001110110110]) = 0bin0);
-ASSERT((X[0bin001110110111] & Y[0bin001110110111]) = 0bin0);
-ASSERT((X[0bin001110111000] & Y[0bin001110111000]) = 0bin0);
-ASSERT((X[0bin001110111001] & Y[0bin001110111001]) = 0bin0);
-ASSERT((X[0bin001110111010] & Y[0bin001110111010]) = 0bin0);
-ASSERT((X[0bin001110111011] & Y[0bin001110111011]) = 0bin0);
-ASSERT((X[0bin001110111100] & Y[0bin001110111100]) = 0bin0);
-ASSERT((X[0bin001110111101] & Y[0bin001110111101]) = 0bin0);
-ASSERT((X[0bin001110111110] & Y[0bin001110111110]) = 0bin0);
-ASSERT((X[0bin001110111111] & Y[0bin001110111111]) = 0bin0);
-ASSERT((X[0bin001111000000] & Y[0bin001111000000]) = 0bin0);
-ASSERT((X[0bin001111000001] & Y[0bin001111000001]) = 0bin0);
-ASSERT((X[0bin001111000010] & Y[0bin001111000010]) = 0bin0);
-ASSERT((X[0bin001111000011] & Y[0bin001111000011]) = 0bin0);
-ASSERT((X[0bin001111000100] & Y[0bin001111000100]) = 0bin0);
-ASSERT((X[0bin001111000101] & Y[0bin001111000101]) = 0bin0);
-ASSERT((X[0bin001111000110] & Y[0bin001111000110]) = 0bin0);
-ASSERT((X[0bin001111000111] & Y[0bin001111000111]) = 0bin0);
-ASSERT((X[0bin001111001000] & Y[0bin001111001000]) = 0bin0);
-ASSERT((X[0bin001111001001] & Y[0bin001111001001]) = 0bin0);
-ASSERT((X[0bin001111001010] & Y[0bin001111001010]) = 0bin0);
-ASSERT((X[0bin001111001011] & Y[0bin001111001011]) = 0bin0);
-ASSERT((X[0bin001111001100] & Y[0bin001111001100]) = 0bin0);
-ASSERT((X[0bin001111001101] & Y[0bin001111001101]) = 0bin0);
-ASSERT((X[0bin001111001110] & Y[0bin001111001110]) = 0bin0);
-ASSERT((X[0bin001111001111] & Y[0bin001111001111]) = 0bin0);
-ASSERT((X[0bin001111010000] & Y[0bin001111010000]) = 0bin0);
-ASSERT((X[0bin001111010001] & Y[0bin001111010001]) = 0bin0);
-ASSERT((X[0bin001111010010] & Y[0bin001111010010]) = 0bin0);
-ASSERT((X[0bin001111010011] & Y[0bin001111010011]) = 0bin0);
-ASSERT((X[0bin001111010100] & Y[0bin001111010100]) = 0bin0);
-ASSERT((X[0bin001111010101] & Y[0bin001111010101]) = 0bin0);
-ASSERT((X[0bin001111010110] & Y[0bin001111010110]) = 0bin0);
-ASSERT((X[0bin001111010111] & Y[0bin001111010111]) = 0bin0);
-ASSERT((X[0bin001111011000] & Y[0bin001111011000]) = 0bin0);
-ASSERT((X[0bin001111011001] & Y[0bin001111011001]) = 0bin0);
-ASSERT((X[0bin001111011010] & Y[0bin001111011010]) = 0bin0);
-ASSERT((X[0bin001111011100] & Y[0bin001111011100]) = 0bin0);
-ASSERT((X[0bin001111011101] & Y[0bin001111011101]) = 0bin0);
-ASSERT((X[0bin001111011110] & Y[0bin001111011110]) = 0bin0);
-ASSERT((X[0bin001111011111] & Y[0bin001111011111]) = 0bin0);
-ASSERT((X[0bin001111100000] & Y[0bin001111100000]) = 0bin0);
-ASSERT((X[0bin001111100001] & Y[0bin001111100001]) = 0bin0);
-ASSERT((X[0bin001111100010] & Y[0bin001111100010]) = 0bin0);
-ASSERT((X[0bin001111100011] & Y[0bin001111100011]) = 0bin0);
-ASSERT((X[0bin001111100100] & Y[0bin001111100100]) = 0bin0);
-ASSERT((X[0bin001111100101] & Y[0bin001111100101]) = 0bin0);
-ASSERT((X[0bin001111100110] & Y[0bin001111100110]) = 0bin0);
-ASSERT((X[0bin001111100111] & Y[0bin001111100111]) = 0bin0);
-ASSERT((X[0bin001111101000] & Y[0bin001111101000]) = 0bin0);
-ASSERT((X[0bin001111101001] & Y[0bin001111101001]) = 0bin0);
-ASSERT((X[0bin001111101010] & Y[0bin001111101010]) = 0bin0);
-ASSERT((X[0bin001111101011] & Y[0bin001111101011]) = 0bin0);
-ASSERT((X[0bin001111101100] & Y[0bin001111101100]) = 0bin0);
-ASSERT((X[0bin001111101101] & Y[0bin001111101101]) = 0bin0);
-ASSERT((X[0bin001111101110] & Y[0bin001111101110]) = 0bin0);
-ASSERT((X[0bin001111101111] & Y[0bin001111101111]) = 0bin0);
-ASSERT((X[0bin001111110000] & Y[0bin001111110000]) = 0bin0);
-ASSERT((X[0bin001111110001] & Y[0bin001111110001]) = 0bin0);
-ASSERT((X[0bin001111110010] & Y[0bin001111110010]) = 0bin0);
-ASSERT((X[0bin001111110011] & Y[0bin001111110011]) = 0bin0);
-ASSERT((X[0bin001111110100] & Y[0bin001111110100]) = 0bin0);
-ASSERT((X[0bin001111110101] & Y[0bin001111110101]) = 0bin0);
-ASSERT((X[0bin001111110110] & Y[0bin001111110110]) = 0bin0);
-ASSERT((X[0bin001111110111] & Y[0bin001111110111]) = 0bin0);
-ASSERT((X[0bin001111111000] & Y[0bin001111111000]) = 0bin0);
-ASSERT((X[0bin001111111001] & Y[0bin001111111001]) = 0bin0);
-ASSERT((X[0bin001111111010] & Y[0bin001111111010]) = 0bin0);
-ASSERT((X[0bin001111111011] & Y[0bin001111111011]) = 0bin0);
-ASSERT((X[0bin001111111100] & Y[0bin001111111100]) = 0bin0);
-ASSERT((X[0bin001111111101] & Y[0bin001111111101]) = 0bin0);
-ASSERT((X[0bin001111111110] & Y[0bin001111111110]) = 0bin0);
-ASSERT((X[0bin001111111111] & Y[0bin001111111111]) = 0bin0);
-ASSERT((X[0bin010000000000] & Y[0bin010000000000]) = 0bin0);
-ASSERT((X[0bin010000000001] & Y[0bin010000000001]) = 0bin0);
-ASSERT((X[0bin010000000010] & Y[0bin010000000010]) = 0bin0);
-ASSERT((X[0bin010000000011] & Y[0bin010000000011]) = 0bin0);
-ASSERT((X[0bin010000000100] & Y[0bin010000000100]) = 0bin0);
-ASSERT((X[0bin010000000101] & Y[0bin010000000101]) = 0bin0);
-ASSERT((X[0bin010000000110] & Y[0bin010000000110]) = 0bin0);
-ASSERT((X[0bin010000000111] & Y[0bin010000000111]) = 0bin0);
-ASSERT((X[0bin010000001000] & Y[0bin010000001000]) = 0bin0);
-ASSERT((X[0bin010000001001] & Y[0bin010000001001]) = 0bin0);
-ASSERT((X[0bin010000001011] & Y[0bin010000001011]) = 0bin0);
-ASSERT((X[0bin010000001100] & Y[0bin010000001100]) = 0bin0);
-ASSERT((X[0bin010000001101] & Y[0bin010000001101]) = 0bin0);
-ASSERT((X[0bin010000001110] & Y[0bin010000001110]) = 0bin0);
-ASSERT((X[0bin010000001111] & Y[0bin010000001111]) = 0bin0);
-ASSERT((X[0bin010000010000] & Y[0bin010000010000]) = 0bin0);
-ASSERT((X[0bin010000010001] & Y[0bin010000010001]) = 0bin0);
-ASSERT((X[0bin010000010010] & Y[0bin010000010010]) = 0bin0);
-ASSERT((X[0bin010000010011] & Y[0bin010000010011]) = 0bin0);
-ASSERT((X[0bin010000010100] & Y[0bin010000010100]) = 0bin0);
-ASSERT((X[0bin010000010101] & Y[0bin010000010101]) = 0bin0);
-ASSERT((X[0bin010000010110] & Y[0bin010000010110]) = 0bin0);
-ASSERT((X[0bin010000010111] & Y[0bin010000010111]) = 0bin0);
-ASSERT((X[0bin010000011000] & Y[0bin010000011000]) = 0bin0);
-ASSERT((X[0bin010000011001] & Y[0bin010000011001]) = 0bin0);
-ASSERT((X[0bin010000011010] & Y[0bin010000011010]) = 0bin0);
-ASSERT((X[0bin010000011011] & Y[0bin010000011011]) = 0bin0);
-ASSERT((X[0bin010000011100] & Y[0bin010000011100]) = 0bin0);
-ASSERT((X[0bin010000011101] & Y[0bin010000011101]) = 0bin0);
-ASSERT((X[0bin010000011110] & Y[0bin010000011110]) = 0bin0);
-ASSERT((X[0bin010000011111] & Y[0bin010000011111]) = 0bin0);
-ASSERT((X[0bin010000100000] & Y[0bin010000100000]) = 0bin0);
-ASSERT((X[0bin010000100001] & Y[0bin010000100001]) = 0bin0);
-ASSERT((X[0bin010000100010] & Y[0bin010000100010]) = 0bin0);
-ASSERT((X[0bin010000100011] & Y[0bin010000100011]) = 0bin0);
-ASSERT((X[0bin010000100100] & Y[0bin010000100100]) = 0bin0);
-ASSERT((X[0bin010000100101] & Y[0bin010000100101]) = 0bin0);
-ASSERT((X[0bin010000100110] & Y[0bin010000100110]) = 0bin0);
-ASSERT((X[0bin010000100111] & Y[0bin010000100111]) = 0bin0);
-ASSERT((X[0bin010000101000] & Y[0bin010000101000]) = 0bin0);
-ASSERT((X[0bin010000101001] & Y[0bin010000101001]) = 0bin0);
-ASSERT((X[0bin010000101010] & Y[0bin010000101010]) = 0bin0);
-ASSERT((X[0bin010000101011] & Y[0bin010000101011]) = 0bin0);
-ASSERT((X[0bin010000101100] & Y[0bin010000101100]) = 0bin0);
-ASSERT((X[0bin010000101101] & Y[0bin010000101101]) = 0bin0);
-ASSERT((X[0bin010000101110] & Y[0bin010000101110]) = 0bin0);
-ASSERT((X[0bin010000101111] & Y[0bin010000101111]) = 0bin0);
-ASSERT((X[0bin010000110000] & Y[0bin010000110000]) = 0bin0);
-ASSERT((X[0bin010000110001] & Y[0bin010000110001]) = 0bin0);
-ASSERT((X[0bin010000110010] & Y[0bin010000110010]) = 0bin0);
-ASSERT((X[0bin010000110011] & Y[0bin010000110011]) = 0bin0);
-ASSERT((X[0bin010000110100] & Y[0bin010000110100]) = 0bin0);
-ASSERT((X[0bin010000110101] & Y[0bin010000110101]) = 0bin0);
-ASSERT((X[0bin010000110110] & Y[0bin010000110110]) = 0bin0);
-ASSERT((X[0bin010000110111] & Y[0bin010000110111]) = 0bin0);
-ASSERT((X[0bin010000111000] & Y[0bin010000111000]) = 0bin0);
-ASSERT((X[0bin010000111010] & Y[0bin010000111010]) = 0bin0);
-ASSERT((X[0bin010000111011] & Y[0bin010000111011]) = 0bin0);
-ASSERT((X[0bin010000111100] & Y[0bin010000111100]) = 0bin0);
-ASSERT((X[0bin010000111101] & Y[0bin010000111101]) = 0bin0);
-ASSERT((X[0bin010000111110] & Y[0bin010000111110]) = 0bin0);
-ASSERT((X[0bin010000111111] & Y[0bin010000111111]) = 0bin0);
-ASSERT((X[0bin010001000000] & Y[0bin010001000000]) = 0bin0);
-ASSERT((X[0bin010001000001] & Y[0bin010001000001]) = 0bin0);
-ASSERT((X[0bin010001000010] & Y[0bin010001000010]) = 0bin0);
-ASSERT((X[0bin010001000011] & Y[0bin010001000011]) = 0bin0);
-ASSERT((X[0bin010001000100] & Y[0bin010001000100]) = 0bin0);
-ASSERT((X[0bin010001000101] & Y[0bin010001000101]) = 0bin0);
-ASSERT((X[0bin010001000110] & Y[0bin010001000110]) = 0bin0);
-ASSERT((X[0bin010001000111] & Y[0bin010001000111]) = 0bin0);
-ASSERT((X[0bin010001001000] & Y[0bin010001001000]) = 0bin0);
-ASSERT((X[0bin010001001001] & Y[0bin010001001001]) = 0bin0);
-ASSERT((X[0bin010001001010] & Y[0bin010001001010]) = 0bin0);
-ASSERT((X[0bin010001001011] & Y[0bin010001001011]) = 0bin0);
-ASSERT((X[0bin010001001100] & Y[0bin010001001100]) = 0bin0);
-ASSERT((X[0bin010001001101] & Y[0bin010001001101]) = 0bin0);
-ASSERT((X[0bin010001001110] & Y[0bin010001001110]) = 0bin0);
-ASSERT((X[0bin010001001111] & Y[0bin010001001111]) = 0bin0);
-ASSERT((X[0bin010001010000] & Y[0bin010001010000]) = 0bin0);
-ASSERT((X[0bin010001010001] & Y[0bin010001010001]) = 0bin0);
-ASSERT((X[0bin010001010010] & Y[0bin010001010010]) = 0bin0);
-ASSERT((X[0bin010001010011] & Y[0bin010001010011]) = 0bin0);
-ASSERT((X[0bin010001010100] & Y[0bin010001010100]) = 0bin0);
-ASSERT((X[0bin010001010101] & Y[0bin010001010101]) = 0bin0);
-ASSERT((X[0bin010001010110] & Y[0bin010001010110]) = 0bin0);
-ASSERT((X[0bin010001010111] & Y[0bin010001010111]) = 0bin0);
-ASSERT((X[0bin010001011000] & Y[0bin010001011000]) = 0bin0);
-ASSERT((X[0bin010001011001] & Y[0bin010001011001]) = 0bin0);
-ASSERT((X[0bin010001011010] & Y[0bin010001011010]) = 0bin0);
-ASSERT((X[0bin010001011011] & Y[0bin010001011011]) = 0bin0);
-ASSERT((X[0bin010001011100] & Y[0bin010001011100]) = 0bin0);
-ASSERT((X[0bin010001011101] & Y[0bin010001011101]) = 0bin0);
-ASSERT((X[0bin010001011110] & Y[0bin010001011110]) = 0bin0);
-ASSERT((X[0bin010001011111] & Y[0bin010001011111]) = 0bin0);
-ASSERT((X[0bin010001100000] & Y[0bin010001100000]) = 0bin0);
-ASSERT((X[0bin010001100001] & Y[0bin010001100001]) = 0bin0);
-ASSERT((X[0bin010001100010] & Y[0bin010001100010]) = 0bin0);
-ASSERT((X[0bin010001100011] & Y[0bin010001100011]) = 0bin0);
-ASSERT((X[0bin010001100100] & Y[0bin010001100100]) = 0bin0);
-ASSERT((X[0bin010001100101] & Y[0bin010001100101]) = 0bin0);
-ASSERT((X[0bin010001100110] & Y[0bin010001100110]) = 0bin0);
-ASSERT((X[0bin010001100111] & Y[0bin010001100111]) = 0bin0);
-ASSERT((X[0bin010001101001] & Y[0bin010001101001]) = 0bin0);
-ASSERT((X[0bin010001101010] & Y[0bin010001101010]) = 0bin0);
-ASSERT((X[0bin010001101011] & Y[0bin010001101011]) = 0bin0);
-ASSERT((X[0bin010001101100] & Y[0bin010001101100]) = 0bin0);
-ASSERT((X[0bin010001101101] & Y[0bin010001101101]) = 0bin0);
-ASSERT((X[0bin010001101110] & Y[0bin010001101110]) = 0bin0);
-ASSERT((X[0bin010001101111] & Y[0bin010001101111]) = 0bin0);
-ASSERT((X[0bin010001110000] & Y[0bin010001110000]) = 0bin0);
-ASSERT((X[0bin010001110001] & Y[0bin010001110001]) = 0bin0);
-ASSERT((X[0bin010001110010] & Y[0bin010001110010]) = 0bin0);
-ASSERT((X[0bin010001110011] & Y[0bin010001110011]) = 0bin0);
-ASSERT((X[0bin010001110100] & Y[0bin010001110100]) = 0bin0);
-ASSERT((X[0bin010001110101] & Y[0bin010001110101]) = 0bin0);
-ASSERT((X[0bin010001110110] & Y[0bin010001110110]) = 0bin0);
-ASSERT((X[0bin010001110111] & Y[0bin010001110111]) = 0bin0);
-ASSERT((X[0bin010001111000] & Y[0bin010001111000]) = 0bin0);
-ASSERT((X[0bin010001111001] & Y[0bin010001111001]) = 0bin0);
-ASSERT((X[0bin010001111010] & Y[0bin010001111010]) = 0bin0);
-ASSERT((X[0bin010001111011] & Y[0bin010001111011]) = 0bin0);
-ASSERT((X[0bin010001111100] & Y[0bin010001111100]) = 0bin0);
-ASSERT((X[0bin010001111101] & Y[0bin010001111101]) = 0bin0);
-ASSERT((X[0bin010001111110] & Y[0bin010001111110]) = 0bin0);
-ASSERT((X[0bin010001111111] & Y[0bin010001111111]) = 0bin0);
-ASSERT((X[0bin010010000000] & Y[0bin010010000000]) = 0bin0);
-ASSERT((X[0bin010010000001] & Y[0bin010010000001]) = 0bin0);
-ASSERT((X[0bin010010000010] & Y[0bin010010000010]) = 0bin0);
-ASSERT((X[0bin010010000011] & Y[0bin010010000011]) = 0bin0);
-ASSERT((X[0bin010010000100] & Y[0bin010010000100]) = 0bin0);
-ASSERT((X[0bin010010000101] & Y[0bin010010000101]) = 0bin0);
-ASSERT((X[0bin010010000110] & Y[0bin010010000110]) = 0bin0);
-ASSERT((X[0bin010010000111] & Y[0bin010010000111]) = 0bin0);
-ASSERT((X[0bin010010001000] & Y[0bin010010001000]) = 0bin0);
-ASSERT((X[0bin010010001001] & Y[0bin010010001001]) = 0bin0);
-ASSERT((X[0bin010010001010] & Y[0bin010010001010]) = 0bin0);
-ASSERT((X[0bin010010001011] & Y[0bin010010001011]) = 0bin0);
-ASSERT((X[0bin010010001100] & Y[0bin010010001100]) = 0bin0);
-ASSERT((X[0bin010010001101] & Y[0bin010010001101]) = 0bin0);
-ASSERT((X[0bin010010001110] & Y[0bin010010001110]) = 0bin0);
-ASSERT((X[0bin010010001111] & Y[0bin010010001111]) = 0bin0);
-ASSERT((X[0bin010010010000] & Y[0bin010010010000]) = 0bin0);
-ASSERT((X[0bin010010010001] & Y[0bin010010010001]) = 0bin0);
-ASSERT((X[0bin010010010010] & Y[0bin010010010010]) = 0bin0);
-ASSERT((X[0bin010010010011] & Y[0bin010010010011]) = 0bin0);
-ASSERT((X[0bin010010010100] & Y[0bin010010010100]) = 0bin0);
-ASSERT((X[0bin010010010101] & Y[0bin010010010101]) = 0bin0);
-ASSERT((X[0bin010010010110] & Y[0bin010010010110]) = 0bin0);
-ASSERT((X[0bin010010011000] & Y[0bin010010011000]) = 0bin0);
-ASSERT((X[0bin010010011001] & Y[0bin010010011001]) = 0bin0);
-ASSERT((X[0bin010010011010] & Y[0bin010010011010]) = 0bin0);
-ASSERT((X[0bin010010011011] & Y[0bin010010011011]) = 0bin0);
-ASSERT((X[0bin010010011100] & Y[0bin010010011100]) = 0bin0);
-ASSERT((X[0bin010010011101] & Y[0bin010010011101]) = 0bin0);
-ASSERT((X[0bin010010011110] & Y[0bin010010011110]) = 0bin0);
-ASSERT((X[0bin010010011111] & Y[0bin010010011111]) = 0bin0);
-ASSERT((X[0bin010010100000] & Y[0bin010010100000]) = 0bin0);
-ASSERT((X[0bin010010100001] & Y[0bin010010100001]) = 0bin0);
-ASSERT((X[0bin010010100010] & Y[0bin010010100010]) = 0bin0);
-ASSERT((X[0bin010010100011] & Y[0bin010010100011]) = 0bin0);
-ASSERT((X[0bin010010100100] & Y[0bin010010100100]) = 0bin0);
-ASSERT((X[0bin010010100101] & Y[0bin010010100101]) = 0bin0);
-ASSERT((X[0bin010010100110] & Y[0bin010010100110]) = 0bin0);
-ASSERT((X[0bin010010100111] & Y[0bin010010100111]) = 0bin0);
-ASSERT((X[0bin010010101000] & Y[0bin010010101000]) = 0bin0);
-ASSERT((X[0bin010010101001] & Y[0bin010010101001]) = 0bin0);
-ASSERT((X[0bin010010101010] & Y[0bin010010101010]) = 0bin0);
-ASSERT((X[0bin010010101011] & Y[0bin010010101011]) = 0bin0);
-ASSERT((X[0bin010010101100] & Y[0bin010010101100]) = 0bin0);
-ASSERT((X[0bin010010101101] & Y[0bin010010101101]) = 0bin0);
-ASSERT((X[0bin010010101110] & Y[0bin010010101110]) = 0bin0);
-ASSERT((X[0bin010010101111] & Y[0bin010010101111]) = 0bin0);
-ASSERT((X[0bin010010110000] & Y[0bin010010110000]) = 0bin0);
-ASSERT((X[0bin010010110001] & Y[0bin010010110001]) = 0bin0);
-ASSERT((X[0bin010010110010] & Y[0bin010010110010]) = 0bin0);
-ASSERT((X[0bin010010110011] & Y[0bin010010110011]) = 0bin0);
-ASSERT((X[0bin010010110100] & Y[0bin010010110100]) = 0bin0);
-ASSERT((X[0bin010010110101] & Y[0bin010010110101]) = 0bin0);
-ASSERT((X[0bin010010110110] & Y[0bin010010110110]) = 0bin0);
-ASSERT((X[0bin010010110111] & Y[0bin010010110111]) = 0bin0);
-ASSERT((X[0bin010010111000] & Y[0bin010010111000]) = 0bin0);
-ASSERT((X[0bin010010111001] & Y[0bin010010111001]) = 0bin0);
-ASSERT((X[0bin010010111010] & Y[0bin010010111010]) = 0bin0);
-ASSERT((X[0bin010010111011] & Y[0bin010010111011]) = 0bin0);
-ASSERT((X[0bin010010111100] & Y[0bin010010111100]) = 0bin0);
-ASSERT((X[0bin010010111101] & Y[0bin010010111101]) = 0bin0);
-ASSERT((X[0bin010010111110] & Y[0bin010010111110]) = 0bin0);
-ASSERT((X[0bin010010111111] & Y[0bin010010111111]) = 0bin0);
-ASSERT((X[0bin010011000000] & Y[0bin010011000000]) = 0bin0);
-ASSERT((X[0bin010011000001] & Y[0bin010011000001]) = 0bin0);
-ASSERT((X[0bin010011000010] & Y[0bin010011000010]) = 0bin0);
-ASSERT((X[0bin010011000011] & Y[0bin010011000011]) = 0bin0);
-ASSERT((X[0bin010011000100] & Y[0bin010011000100]) = 0bin0);
-ASSERT((X[0bin010011000101] & Y[0bin010011000101]) = 0bin0);
-ASSERT((X[0bin010011000111] & Y[0bin010011000111]) = 0bin0);
-ASSERT((X[0bin010011001000] & Y[0bin010011001000]) = 0bin0);
-ASSERT((X[0bin010011001001] & Y[0bin010011001001]) = 0bin0);
-ASSERT((X[0bin010011001010] & Y[0bin010011001010]) = 0bin0);
-ASSERT((X[0bin010011001011] & Y[0bin010011001011]) = 0bin0);
-ASSERT((X[0bin010011001100] & Y[0bin010011001100]) = 0bin0);
-ASSERT((X[0bin010011001101] & Y[0bin010011001101]) = 0bin0);
-ASSERT((X[0bin010011001110] & Y[0bin010011001110]) = 0bin0);
-ASSERT((X[0bin010011001111] & Y[0bin010011001111]) = 0bin0);
-ASSERT((X[0bin010011010000] & Y[0bin010011010000]) = 0bin0);
-ASSERT((X[0bin010011010001] & Y[0bin010011010001]) = 0bin0);
-ASSERT((X[0bin010011010010] & Y[0bin010011010010]) = 0bin0);
-ASSERT((X[0bin010011010011] & Y[0bin010011010011]) = 0bin0);
-ASSERT((X[0bin010011010100] & Y[0bin010011010100]) = 0bin0);
-ASSERT((X[0bin010011010101] & Y[0bin010011010101]) = 0bin0);
-ASSERT((X[0bin010011010110] & Y[0bin010011010110]) = 0bin0);
-ASSERT((X[0bin010011010111] & Y[0bin010011010111]) = 0bin0);
-ASSERT((X[0bin010011011000] & Y[0bin010011011000]) = 0bin0);
-ASSERT((X[0bin010011011001] & Y[0bin010011011001]) = 0bin0);
-ASSERT((X[0bin010011011010] & Y[0bin010011011010]) = 0bin0);
-ASSERT((X[0bin010011011011] & Y[0bin010011011011]) = 0bin0);
-ASSERT((X[0bin010011011100] & Y[0bin010011011100]) = 0bin0);
-ASSERT((X[0bin010011011101] & Y[0bin010011011101]) = 0bin0);
-ASSERT((X[0bin010011011110] & Y[0bin010011011110]) = 0bin0);
-ASSERT((X[0bin010011011111] & Y[0bin010011011111]) = 0bin0);
-ASSERT((X[0bin010011100000] & Y[0bin010011100000]) = 0bin0);
-ASSERT((X[0bin010011100001] & Y[0bin010011100001]) = 0bin0);
-ASSERT((X[0bin010011100010] & Y[0bin010011100010]) = 0bin0);
-ASSERT((X[0bin010011100011] & Y[0bin010011100011]) = 0bin0);
-ASSERT((X[0bin010011100100] & Y[0bin010011100100]) = 0bin0);
-ASSERT((X[0bin010011100101] & Y[0bin010011100101]) = 0bin0);
-ASSERT((X[0bin010011100110] & Y[0bin010011100110]) = 0bin0);
-ASSERT((X[0bin010011100111] & Y[0bin010011100111]) = 0bin0);
-ASSERT((X[0bin010011101000] & Y[0bin010011101000]) = 0bin0);
-ASSERT((X[0bin010011101001] & Y[0bin010011101001]) = 0bin0);
-ASSERT((X[0bin010011101010] & Y[0bin010011101010]) = 0bin0);
-ASSERT((X[0bin010011101011] & Y[0bin010011101011]) = 0bin0);
-ASSERT((X[0bin010011101100] & Y[0bin010011101100]) = 0bin0);
-ASSERT((X[0bin010011101101] & Y[0bin010011101101]) = 0bin0);
-ASSERT((X[0bin010011101110] & Y[0bin010011101110]) = 0bin0);
-ASSERT((X[0bin010011101111] & Y[0bin010011101111]) = 0bin0);
-ASSERT((X[0bin010011110000] & Y[0bin010011110000]) = 0bin0);
-ASSERT((X[0bin010011110001] & Y[0bin010011110001]) = 0bin0);
-ASSERT((X[0bin010011110010] & Y[0bin010011110010]) = 0bin0);
-ASSERT((X[0bin010011110011] & Y[0bin010011110011]) = 0bin0);
-ASSERT((X[0bin010011110100] & Y[0bin010011110100]) = 0bin0);
-ASSERT((X[0bin010011110110] & Y[0bin010011110110]) = 0bin0);
-ASSERT((X[0bin010011110111] & Y[0bin010011110111]) = 0bin0);
-ASSERT((X[0bin010011111000] & Y[0bin010011111000]) = 0bin0);
-ASSERT((X[0bin010011111001] & Y[0bin010011111001]) = 0bin0);
-ASSERT((X[0bin010011111010] & Y[0bin010011111010]) = 0bin0);
-ASSERT((X[0bin010011111011] & Y[0bin010011111011]) = 0bin0);
-ASSERT((X[0bin010011111100] & Y[0bin010011111100]) = 0bin0);
-ASSERT((X[0bin010011111101] & Y[0bin010011111101]) = 0bin0);
-ASSERT((X[0bin010011111110] & Y[0bin010011111110]) = 0bin0);
-ASSERT((X[0bin010011111111] & Y[0bin010011111111]) = 0bin0);
-ASSERT((X[0bin010100000000] & Y[0bin010100000000]) = 0bin0);
-ASSERT((X[0bin010100000001] & Y[0bin010100000001]) = 0bin0);
-ASSERT((X[0bin010100000010] & Y[0bin010100000010]) = 0bin0);
-ASSERT((X[0bin010100000011] & Y[0bin010100000011]) = 0bin0);
-ASSERT((X[0bin010100000100] & Y[0bin010100000100]) = 0bin0);
-ASSERT((X[0bin010100000101] & Y[0bin010100000101]) = 0bin0);
-ASSERT((X[0bin010100000110] & Y[0bin010100000110]) = 0bin0);
-ASSERT((X[0bin010100000111] & Y[0bin010100000111]) = 0bin0);
-ASSERT((X[0bin010100001000] & Y[0bin010100001000]) = 0bin0);
-ASSERT((X[0bin010100001001] & Y[0bin010100001001]) = 0bin0);
-ASSERT((X[0bin010100001010] & Y[0bin010100001010]) = 0bin0);
-ASSERT((X[0bin010100001011] & Y[0bin010100001011]) = 0bin0);
-ASSERT((X[0bin010100001100] & Y[0bin010100001100]) = 0bin0);
-ASSERT((X[0bin010100001101] & Y[0bin010100001101]) = 0bin0);
-ASSERT((X[0bin010100001110] & Y[0bin010100001110]) = 0bin0);
-ASSERT((X[0bin010100001111] & Y[0bin010100001111]) = 0bin0);
-ASSERT((X[0bin010100010000] & Y[0bin010100010000]) = 0bin0);
-ASSERT((X[0bin010100010001] & Y[0bin010100010001]) = 0bin0);
-ASSERT((X[0bin010100010010] & Y[0bin010100010010]) = 0bin0);
-ASSERT((X[0bin010100010011] & Y[0bin010100010011]) = 0bin0);
-ASSERT((X[0bin010100010100] & Y[0bin010100010100]) = 0bin0);
-ASSERT((X[0bin010100010101] & Y[0bin010100010101]) = 0bin0);
-ASSERT((X[0bin010100010110] & Y[0bin010100010110]) = 0bin0);
-ASSERT((X[0bin010100010111] & Y[0bin010100010111]) = 0bin0);
-ASSERT((X[0bin010100011000] & Y[0bin010100011000]) = 0bin0);
-ASSERT((X[0bin010100011001] & Y[0bin010100011001]) = 0bin0);
-ASSERT((X[0bin010100011010] & Y[0bin010100011010]) = 0bin0);
-ASSERT((X[0bin010100011011] & Y[0bin010100011011]) = 0bin0);
-ASSERT((X[0bin010100011100] & Y[0bin010100011100]) = 0bin0);
-ASSERT((X[0bin010100011101] & Y[0bin010100011101]) = 0bin0);
-ASSERT((X[0bin010100011110] & Y[0bin010100011110]) = 0bin0);
-ASSERT((X[0bin010100011111] & Y[0bin010100011111]) = 0bin0);
-ASSERT((X[0bin010100100000] & Y[0bin010100100000]) = 0bin0);
-ASSERT((X[0bin010100100001] & Y[0bin010100100001]) = 0bin0);
-ASSERT((X[0bin010100100010] & Y[0bin010100100010]) = 0bin0);
-ASSERT((X[0bin010100100011] & Y[0bin010100100011]) = 0bin0);
-ASSERT((X[0bin010100100101] & Y[0bin010100100101]) = 0bin0);
-ASSERT((X[0bin010100100110] & Y[0bin010100100110]) = 0bin0);
-ASSERT((X[0bin010100100111] & Y[0bin010100100111]) = 0bin0);
-ASSERT((X[0bin010100101000] & Y[0bin010100101000]) = 0bin0);
-ASSERT((X[0bin010100101001] & Y[0bin010100101001]) = 0bin0);
-ASSERT((X[0bin010100101010] & Y[0bin010100101010]) = 0bin0);
-ASSERT((X[0bin010100101011] & Y[0bin010100101011]) = 0bin0);
-ASSERT((X[0bin010100101100] & Y[0bin010100101100]) = 0bin0);
-ASSERT((X[0bin010100101101] & Y[0bin010100101101]) = 0bin0);
-ASSERT((X[0bin010100101110] & Y[0bin010100101110]) = 0bin0);
-ASSERT((X[0bin010100101111] & Y[0bin010100101111]) = 0bin0);
-ASSERT((X[0bin010100110000] & Y[0bin010100110000]) = 0bin0);
-ASSERT((X[0bin010100110001] & Y[0bin010100110001]) = 0bin0);
-ASSERT((X[0bin010100110010] & Y[0bin010100110010]) = 0bin0);
-ASSERT((X[0bin010100110011] & Y[0bin010100110011]) = 0bin0);
-ASSERT((X[0bin010100110100] & Y[0bin010100110100]) = 0bin0);
-ASSERT((X[0bin010100110101] & Y[0bin010100110101]) = 0bin0);
-ASSERT((X[0bin010100110110] & Y[0bin010100110110]) = 0bin0);
-ASSERT((X[0bin010100110111] & Y[0bin010100110111]) = 0bin0);
-ASSERT((X[0bin010100111000] & Y[0bin010100111000]) = 0bin0);
-ASSERT((X[0bin010100111001] & Y[0bin010100111001]) = 0bin0);
-ASSERT((X[0bin010100111010] & Y[0bin010100111010]) = 0bin0);
-ASSERT((X[0bin010100111011] & Y[0bin010100111011]) = 0bin0);
-ASSERT((X[0bin010100111100] & Y[0bin010100111100]) = 0bin0);
-ASSERT((X[0bin010100111101] & Y[0bin010100111101]) = 0bin0);
-ASSERT((X[0bin010100111110] & Y[0bin010100111110]) = 0bin0);
-ASSERT((X[0bin010100111111] & Y[0bin010100111111]) = 0bin0);
-ASSERT((X[0bin010101000000] & Y[0bin010101000000]) = 0bin0);
-ASSERT((X[0bin010101000001] & Y[0bin010101000001]) = 0bin0);
-ASSERT((X[0bin010101000010] & Y[0bin010101000010]) = 0bin0);
-ASSERT((X[0bin010101000011] & Y[0bin010101000011]) = 0bin0);
-ASSERT((X[0bin010101000100] & Y[0bin010101000100]) = 0bin0);
-ASSERT((X[0bin010101000101] & Y[0bin010101000101]) = 0bin0);
-ASSERT((X[0bin010101000110] & Y[0bin010101000110]) = 0bin0);
-ASSERT((X[0bin010101000111] & Y[0bin010101000111]) = 0bin0);
-ASSERT((X[0bin010101001000] & Y[0bin010101001000]) = 0bin0);
-ASSERT((X[0bin010101001001] & Y[0bin010101001001]) = 0bin0);
-ASSERT((X[0bin010101001010] & Y[0bin010101001010]) = 0bin0);
-ASSERT((X[0bin010101001011] & Y[0bin010101001011]) = 0bin0);
-ASSERT((X[0bin010101001100] & Y[0bin010101001100]) = 0bin0);
-ASSERT((X[0bin010101001101] & Y[0bin010101001101]) = 0bin0);
-ASSERT((X[0bin010101001110] & Y[0bin010101001110]) = 0bin0);
-ASSERT((X[0bin010101001111] & Y[0bin010101001111]) = 0bin0);
-ASSERT((X[0bin010101010000] & Y[0bin010101010000]) = 0bin0);
-ASSERT((X[0bin010101010001] & Y[0bin010101010001]) = 0bin0);
-ASSERT((X[0bin010101010010] & Y[0bin010101010010]) = 0bin0);
-ASSERT((X[0bin010101010100] & Y[0bin010101010100]) = 0bin0);
-ASSERT((X[0bin010101010101] & Y[0bin010101010101]) = 0bin0);
-ASSERT((X[0bin010101010110] & Y[0bin010101010110]) = 0bin0);
-ASSERT((X[0bin010101010111] & Y[0bin010101010111]) = 0bin0);
-ASSERT((X[0bin010101011000] & Y[0bin010101011000]) = 0bin0);
-ASSERT((X[0bin010101011001] & Y[0bin010101011001]) = 0bin0);
-ASSERT((X[0bin010101011010] & Y[0bin010101011010]) = 0bin0);
-ASSERT((X[0bin010101011011] & Y[0bin010101011011]) = 0bin0);
-ASSERT((X[0bin010101011100] & Y[0bin010101011100]) = 0bin0);
-ASSERT((X[0bin010101011101] & Y[0bin010101011101]) = 0bin0);
-ASSERT((X[0bin010101011110] & Y[0bin010101011110]) = 0bin0);
-ASSERT((X[0bin010101011111] & Y[0bin010101011111]) = 0bin0);
-ASSERT((X[0bin010101100000] & Y[0bin010101100000]) = 0bin0);
-ASSERT((X[0bin010101100001] & Y[0bin010101100001]) = 0bin0);
-ASSERT((X[0bin010101100010] & Y[0bin010101100010]) = 0bin0);
-ASSERT((X[0bin010101100011] & Y[0bin010101100011]) = 0bin0);
-ASSERT((X[0bin010101100100] & Y[0bin010101100100]) = 0bin0);
-ASSERT((X[0bin010101100101] & Y[0bin010101100101]) = 0bin0);
-ASSERT((X[0bin010101100110] & Y[0bin010101100110]) = 0bin0);
-ASSERT((X[0bin010101100111] & Y[0bin010101100111]) = 0bin0);
-ASSERT((X[0bin010101101000] & Y[0bin010101101000]) = 0bin0);
-ASSERT((X[0bin010101101001] & Y[0bin010101101001]) = 0bin0);
-ASSERT((X[0bin010101101010] & Y[0bin010101101010]) = 0bin0);
-ASSERT((X[0bin010101101011] & Y[0bin010101101011]) = 0bin0);
-ASSERT((X[0bin010101101100] & Y[0bin010101101100]) = 0bin0);
-ASSERT((X[0bin010101101101] & Y[0bin010101101101]) = 0bin0);
-ASSERT((X[0bin010101101110] & Y[0bin010101101110]) = 0bin0);
-ASSERT((X[0bin010101101111] & Y[0bin010101101111]) = 0bin0);
-ASSERT((X[0bin010101110000] & Y[0bin010101110000]) = 0bin0);
-ASSERT((X[0bin010101110001] & Y[0bin010101110001]) = 0bin0);
-ASSERT((X[0bin010101110010] & Y[0bin010101110010]) = 0bin0);
-ASSERT((X[0bin010101110011] & Y[0bin010101110011]) = 0bin0);
-ASSERT((X[0bin010101110100] & Y[0bin010101110100]) = 0bin0);
-ASSERT((X[0bin010101110101] & Y[0bin010101110101]) = 0bin0);
-ASSERT((X[0bin010101110110] & Y[0bin010101110110]) = 0bin0);
-ASSERT((X[0bin010101110111] & Y[0bin010101110111]) = 0bin0);
-ASSERT((X[0bin010101111000] & Y[0bin010101111000]) = 0bin0);
-ASSERT((X[0bin010101111001] & Y[0bin010101111001]) = 0bin0);
-ASSERT((X[0bin010101111010] & Y[0bin010101111010]) = 0bin0);
-ASSERT((X[0bin010101111011] & Y[0bin010101111011]) = 0bin0);
-ASSERT((X[0bin010101111100] & Y[0bin010101111100]) = 0bin0);
-ASSERT((X[0bin010101111101] & Y[0bin010101111101]) = 0bin0);
-ASSERT((X[0bin010101111110] & Y[0bin010101111110]) = 0bin0);
-ASSERT((X[0bin010101111111] & Y[0bin010101111111]) = 0bin0);
-ASSERT((X[0bin010110000000] & Y[0bin010110000000]) = 0bin0);
-ASSERT((X[0bin010110000001] & Y[0bin010110000001]) = 0bin0);
-ASSERT((X[0bin010110000011] & Y[0bin010110000011]) = 0bin0);
-ASSERT((X[0bin010110000100] & Y[0bin010110000100]) = 0bin0);
-ASSERT((X[0bin010110000101] & Y[0bin010110000101]) = 0bin0);
-ASSERT((X[0bin010110000110] & Y[0bin010110000110]) = 0bin0);
-ASSERT((X[0bin010110000111] & Y[0bin010110000111]) = 0bin0);
-ASSERT((X[0bin010110001000] & Y[0bin010110001000]) = 0bin0);
-ASSERT((X[0bin010110001001] & Y[0bin010110001001]) = 0bin0);
-ASSERT((X[0bin010110001010] & Y[0bin010110001010]) = 0bin0);
-ASSERT((X[0bin010110001011] & Y[0bin010110001011]) = 0bin0);
-ASSERT((X[0bin010110001100] & Y[0bin010110001100]) = 0bin0);
-ASSERT((X[0bin010110001101] & Y[0bin010110001101]) = 0bin0);
-ASSERT((X[0bin010110001110] & Y[0bin010110001110]) = 0bin0);
-ASSERT((X[0bin010110001111] & Y[0bin010110001111]) = 0bin0);
-ASSERT((X[0bin010110010000] & Y[0bin010110010000]) = 0bin0);
-ASSERT((X[0bin010110010001] & Y[0bin010110010001]) = 0bin0);
-ASSERT((X[0bin010110010010] & Y[0bin010110010010]) = 0bin0);
-ASSERT((X[0bin010110010011] & Y[0bin010110010011]) = 0bin0);
-ASSERT((X[0bin010110010100] & Y[0bin010110010100]) = 0bin0);
-ASSERT((X[0bin010110010101] & Y[0bin010110010101]) = 0bin0);
-ASSERT((X[0bin010110010110] & Y[0bin010110010110]) = 0bin0);
-ASSERT((X[0bin010110010111] & Y[0bin010110010111]) = 0bin0);
-ASSERT((X[0bin010110011000] & Y[0bin010110011000]) = 0bin0);
-ASSERT((X[0bin010110011001] & Y[0bin010110011001]) = 0bin0);
-ASSERT((X[0bin010110011010] & Y[0bin010110011010]) = 0bin0);
-ASSERT((X[0bin010110011011] & Y[0bin010110011011]) = 0bin0);
-ASSERT((X[0bin010110011100] & Y[0bin010110011100]) = 0bin0);
-ASSERT((X[0bin010110011101] & Y[0bin010110011101]) = 0bin0);
-ASSERT((X[0bin010110011110] & Y[0bin010110011110]) = 0bin0);
-ASSERT((X[0bin010110011111] & Y[0bin010110011111]) = 0bin0);
-ASSERT((X[0bin010110100000] & Y[0bin010110100000]) = 0bin0);
-ASSERT((X[0bin010110100001] & Y[0bin010110100001]) = 0bin0);
-ASSERT((X[0bin010110100010] & Y[0bin010110100010]) = 0bin0);
-ASSERT((X[0bin010110100011] & Y[0bin010110100011]) = 0bin0);
-ASSERT((X[0bin010110100100] & Y[0bin010110100100]) = 0bin0);
-ASSERT((X[0bin010110100101] & Y[0bin010110100101]) = 0bin0);
-ASSERT((X[0bin010110100110] & Y[0bin010110100110]) = 0bin0);
-ASSERT((X[0bin010110100111] & Y[0bin010110100111]) = 0bin0);
-ASSERT((X[0bin010110101000] & Y[0bin010110101000]) = 0bin0);
-ASSERT((X[0bin010110101001] & Y[0bin010110101001]) = 0bin0);
-ASSERT((X[0bin010110101010] & Y[0bin010110101010]) = 0bin0);
-ASSERT((X[0bin010110101011] & Y[0bin010110101011]) = 0bin0);
-ASSERT((X[0bin010110101100] & Y[0bin010110101100]) = 0bin0);
-ASSERT((X[0bin010110101101] & Y[0bin010110101101]) = 0bin0);
-ASSERT((X[0bin010110101110] & Y[0bin010110101110]) = 0bin0);
-ASSERT((X[0bin010110101111] & Y[0bin010110101111]) = 0bin0);
-ASSERT((X[0bin010110110000] & Y[0bin010110110000]) = 0bin0);
-ASSERT((X[0bin010110110010] & Y[0bin010110110010]) = 0bin0);
-ASSERT((X[0bin010110110011] & Y[0bin010110110011]) = 0bin0);
-ASSERT((X[0bin010110110100] & Y[0bin010110110100]) = 0bin0);
-ASSERT((X[0bin010110110101] & Y[0bin010110110101]) = 0bin0);
-ASSERT((X[0bin010110110110] & Y[0bin010110110110]) = 0bin0);
-ASSERT((X[0bin010110110111] & Y[0bin010110110111]) = 0bin0);
-ASSERT((X[0bin010110111000] & Y[0bin010110111000]) = 0bin0);
-ASSERT((X[0bin010110111001] & Y[0bin010110111001]) = 0bin0);
-ASSERT((X[0bin010110111010] & Y[0bin010110111010]) = 0bin0);
-ASSERT((X[0bin010110111011] & Y[0bin010110111011]) = 0bin0);
-ASSERT((X[0bin010110111100] & Y[0bin010110111100]) = 0bin0);
-ASSERT((X[0bin010110111101] & Y[0bin010110111101]) = 0bin0);
-ASSERT((X[0bin010110111110] & Y[0bin010110111110]) = 0bin0);
-ASSERT((X[0bin010110111111] & Y[0bin010110111111]) = 0bin0);
-ASSERT((X[0bin010111000000] & Y[0bin010111000000]) = 0bin0);
-ASSERT((X[0bin010111000001] & Y[0bin010111000001]) = 0bin0);
-ASSERT((X[0bin010111000010] & Y[0bin010111000010]) = 0bin0);
-ASSERT((X[0bin010111000011] & Y[0bin010111000011]) = 0bin0);
-ASSERT((X[0bin010111000100] & Y[0bin010111000100]) = 0bin0);
-ASSERT((X[0bin010111000101] & Y[0bin010111000101]) = 0bin0);
-ASSERT((X[0bin010111000110] & Y[0bin010111000110]) = 0bin0);
-ASSERT((X[0bin010111000111] & Y[0bin010111000111]) = 0bin0);
-ASSERT((X[0bin010111001000] & Y[0bin010111001000]) = 0bin0);
-ASSERT((X[0bin010111001001] & Y[0bin010111001001]) = 0bin0);
-ASSERT((X[0bin010111001010] & Y[0bin010111001010]) = 0bin0);
-ASSERT((X[0bin010111001011] & Y[0bin010111001011]) = 0bin0);
-ASSERT((X[0bin010111001100] & Y[0bin010111001100]) = 0bin0);
-ASSERT((X[0bin010111001101] & Y[0bin010111001101]) = 0bin0);
-ASSERT((X[0bin010111001110] & Y[0bin010111001110]) = 0bin0);
-ASSERT((X[0bin010111001111] & Y[0bin010111001111]) = 0bin0);
-ASSERT((X[0bin010111010000] & Y[0bin010111010000]) = 0bin0);
-ASSERT((X[0bin010111010001] & Y[0bin010111010001]) = 0bin0);
-ASSERT((X[0bin010111010010] & Y[0bin010111010010]) = 0bin0);
-ASSERT((X[0bin010111010011] & Y[0bin010111010011]) = 0bin0);
-ASSERT((X[0bin010111010100] & Y[0bin010111010100]) = 0bin0);
-ASSERT((X[0bin010111010101] & Y[0bin010111010101]) = 0bin0);
-ASSERT((X[0bin010111010110] & Y[0bin010111010110]) = 0bin0);
-ASSERT((X[0bin010111010111] & Y[0bin010111010111]) = 0bin0);
-ASSERT((X[0bin010111011000] & Y[0bin010111011000]) = 0bin0);
-ASSERT((X[0bin010111011001] & Y[0bin010111011001]) = 0bin0);
-ASSERT((X[0bin010111011010] & Y[0bin010111011010]) = 0bin0);
-ASSERT((X[0bin010111011011] & Y[0bin010111011011]) = 0bin0);
-ASSERT((X[0bin010111011100] & Y[0bin010111011100]) = 0bin0);
-ASSERT((X[0bin010111011101] & Y[0bin010111011101]) = 0bin0);
-ASSERT((X[0bin010111011110] & Y[0bin010111011110]) = 0bin0);
-ASSERT((X[0bin010111011111] & Y[0bin010111011111]) = 0bin0);
-ASSERT((X[0bin010111100001] & Y[0bin010111100001]) = 0bin0);
-ASSERT((X[0bin010111100010] & Y[0bin010111100010]) = 0bin0);
-ASSERT((X[0bin010111100011] & Y[0bin010111100011]) = 0bin0);
-ASSERT((X[0bin010111100100] & Y[0bin010111100100]) = 0bin0);
-ASSERT((X[0bin010111100101] & Y[0bin010111100101]) = 0bin0);
-ASSERT((X[0bin010111100110] & Y[0bin010111100110]) = 0bin0);
-ASSERT((X[0bin010111100111] & Y[0bin010111100111]) = 0bin0);
-ASSERT((X[0bin010111101000] & Y[0bin010111101000]) = 0bin0);
-ASSERT((X[0bin010111101001] & Y[0bin010111101001]) = 0bin0);
-ASSERT((X[0bin010111101010] & Y[0bin010111101010]) = 0bin0);
-ASSERT((X[0bin010111101011] & Y[0bin010111101011]) = 0bin0);
-ASSERT((X[0bin010111101100] & Y[0bin010111101100]) = 0bin0);
-ASSERT((X[0bin010111101101] & Y[0bin010111101101]) = 0bin0);
-ASSERT((X[0bin010111101110] & Y[0bin010111101110]) = 0bin0);
-ASSERT((X[0bin010111101111] & Y[0bin010111101111]) = 0bin0);
-ASSERT((X[0bin010111110000] & Y[0bin010111110000]) = 0bin0);
-ASSERT((X[0bin010111110001] & Y[0bin010111110001]) = 0bin0);
-ASSERT((X[0bin010111110010] & Y[0bin010111110010]) = 0bin0);
-ASSERT((X[0bin010111110011] & Y[0bin010111110011]) = 0bin0);
-ASSERT((X[0bin010111110100] & Y[0bin010111110100]) = 0bin0);
-ASSERT((X[0bin010111110101] & Y[0bin010111110101]) = 0bin0);
-ASSERT((X[0bin010111110110] & Y[0bin010111110110]) = 0bin0);
-ASSERT((X[0bin010111110111] & Y[0bin010111110111]) = 0bin0);
-ASSERT((X[0bin010111111000] & Y[0bin010111111000]) = 0bin0);
-ASSERT((X[0bin010111111001] & Y[0bin010111111001]) = 0bin0);
-ASSERT((X[0bin010111111010] & Y[0bin010111111010]) = 0bin0);
-ASSERT((X[0bin010111111011] & Y[0bin010111111011]) = 0bin0);
-ASSERT((X[0bin010111111100] & Y[0bin010111111100]) = 0bin0);
-ASSERT((X[0bin010111111101] & Y[0bin010111111101]) = 0bin0);
-ASSERT((X[0bin010111111110] & Y[0bin010111111110]) = 0bin0);
-ASSERT((X[0bin010111111111] & Y[0bin010111111111]) = 0bin0);
-ASSERT((X[0bin011000000000] & Y[0bin011000000000]) = 0bin0);
-ASSERT((X[0bin011000000001] & Y[0bin011000000001]) = 0bin0);
-ASSERT((X[0bin011000000010] & Y[0bin011000000010]) = 0bin0);
-ASSERT((X[0bin011000000011] & Y[0bin011000000011]) = 0bin0);
-ASSERT((X[0bin011000000100] & Y[0bin011000000100]) = 0bin0);
-ASSERT((X[0bin011000000101] & Y[0bin011000000101]) = 0bin0);
-ASSERT((X[0bin011000000110] & Y[0bin011000000110]) = 0bin0);
-ASSERT((X[0bin011000000111] & Y[0bin011000000111]) = 0bin0);
-ASSERT((X[0bin011000001000] & Y[0bin011000001000]) = 0bin0);
-ASSERT((X[0bin011000001001] & Y[0bin011000001001]) = 0bin0);
-ASSERT((X[0bin011000001010] & Y[0bin011000001010]) = 0bin0);
-ASSERT((X[0bin011000001011] & Y[0bin011000001011]) = 0bin0);
-ASSERT((X[0bin011000001100] & Y[0bin011000001100]) = 0bin0);
-ASSERT((X[0bin011000001101] & Y[0bin011000001101]) = 0bin0);
-ASSERT((X[0bin011000001110] & Y[0bin011000001110]) = 0bin0);
-ASSERT((X[0bin011000010000] & Y[0bin011000010000]) = 0bin0);
-ASSERT((X[0bin011000010001] & Y[0bin011000010001]) = 0bin0);
-ASSERT((X[0bin011000010010] & Y[0bin011000010010]) = 0bin0);
-ASSERT((X[0bin011000010011] & Y[0bin011000010011]) = 0bin0);
-ASSERT((X[0bin011000010100] & Y[0bin011000010100]) = 0bin0);
-ASSERT((X[0bin011000010101] & Y[0bin011000010101]) = 0bin0);
-ASSERT((X[0bin011000010110] & Y[0bin011000010110]) = 0bin0);
-ASSERT((X[0bin011000010111] & Y[0bin011000010111]) = 0bin0);
-ASSERT((X[0bin011000011000] & Y[0bin011000011000]) = 0bin0);
-ASSERT((X[0bin011000011001] & Y[0bin011000011001]) = 0bin0);
-ASSERT((X[0bin011000011010] & Y[0bin011000011010]) = 0bin0);
-ASSERT((X[0bin011000011011] & Y[0bin011000011011]) = 0bin0);
-ASSERT((X[0bin011000011100] & Y[0bin011000011100]) = 0bin0);
-ASSERT((X[0bin011000011101] & Y[0bin011000011101]) = 0bin0);
-ASSERT((X[0bin011000011110] & Y[0bin011000011110]) = 0bin0);
-ASSERT((X[0bin011000011111] & Y[0bin011000011111]) = 0bin0);
-ASSERT((X[0bin011000100000] & Y[0bin011000100000]) = 0bin0);
-ASSERT((X[0bin011000100001] & Y[0bin011000100001]) = 0bin0);
-ASSERT((X[0bin011000100010] & Y[0bin011000100010]) = 0bin0);
-ASSERT((X[0bin011000100011] & Y[0bin011000100011]) = 0bin0);
-ASSERT((X[0bin011000100100] & Y[0bin011000100100]) = 0bin0);
-ASSERT((X[0bin011000100101] & Y[0bin011000100101]) = 0bin0);
-ASSERT((X[0bin011000100110] & Y[0bin011000100110]) = 0bin0);
-ASSERT((X[0bin011000100111] & Y[0bin011000100111]) = 0bin0);
-ASSERT((X[0bin011000101000] & Y[0bin011000101000]) = 0bin0);
-ASSERT((X[0bin011000101001] & Y[0bin011000101001]) = 0bin0);
-ASSERT((X[0bin011000101010] & Y[0bin011000101010]) = 0bin0);
-ASSERT((X[0bin011000101011] & Y[0bin011000101011]) = 0bin0);
-ASSERT((X[0bin011000101100] & Y[0bin011000101100]) = 0bin0);
-ASSERT((X[0bin011000101101] & Y[0bin011000101101]) = 0bin0);
-ASSERT((X[0bin011000101110] & Y[0bin011000101110]) = 0bin0);
-ASSERT((X[0bin011000101111] & Y[0bin011000101111]) = 0bin0);
-ASSERT((X[0bin011000110000] & Y[0bin011000110000]) = 0bin0);
-ASSERT((X[0bin011000110001] & Y[0bin011000110001]) = 0bin0);
-ASSERT((X[0bin011000110010] & Y[0bin011000110010]) = 0bin0);
-ASSERT((X[0bin011000110011] & Y[0bin011000110011]) = 0bin0);
-ASSERT((X[0bin011000110100] & Y[0bin011000110100]) = 0bin0);
-ASSERT((X[0bin011000110101] & Y[0bin011000110101]) = 0bin0);
-ASSERT((X[0bin011000110110] & Y[0bin011000110110]) = 0bin0);
-ASSERT((X[0bin011000110111] & Y[0bin011000110111]) = 0bin0);
-ASSERT((X[0bin011000111000] & Y[0bin011000111000]) = 0bin0);
-ASSERT((X[0bin011000111001] & Y[0bin011000111001]) = 0bin0);
-ASSERT((X[0bin011000111010] & Y[0bin011000111010]) = 0bin0);
-ASSERT((X[0bin011000111011] & Y[0bin011000111011]) = 0bin0);
-ASSERT((X[0bin011000111100] & Y[0bin011000111100]) = 0bin0);
-ASSERT((X[0bin011000111101] & Y[0bin011000111101]) = 0bin0);
-ASSERT((X[0bin011000111111] & Y[0bin011000111111]) = 0bin0);
-ASSERT((X[0bin011001000000] & Y[0bin011001000000]) = 0bin0);
-ASSERT((X[0bin011001000001] & Y[0bin011001000001]) = 0bin0);
-ASSERT((X[0bin011001000010] & Y[0bin011001000010]) = 0bin0);
-ASSERT((X[0bin011001000011] & Y[0bin011001000011]) = 0bin0);
-ASSERT((X[0bin011001000100] & Y[0bin011001000100]) = 0bin0);
-ASSERT((X[0bin011001000101] & Y[0bin011001000101]) = 0bin0);
-ASSERT((X[0bin011001000110] & Y[0bin011001000110]) = 0bin0);
-ASSERT((X[0bin011001000111] & Y[0bin011001000111]) = 0bin0);
-ASSERT((X[0bin011001001000] & Y[0bin011001001000]) = 0bin0);
-ASSERT((X[0bin011001001001] & Y[0bin011001001001]) = 0bin0);
-ASSERT((X[0bin011001001010] & Y[0bin011001001010]) = 0bin0);
-ASSERT((X[0bin011001001011] & Y[0bin011001001011]) = 0bin0);
-ASSERT((X[0bin011001001100] & Y[0bin011001001100]) = 0bin0);
-ASSERT((X[0bin011001001101] & Y[0bin011001001101]) = 0bin0);
-ASSERT((X[0bin011001001110] & Y[0bin011001001110]) = 0bin0);
-ASSERT((X[0bin011001001111] & Y[0bin011001001111]) = 0bin0);
-ASSERT((X[0bin011001010000] & Y[0bin011001010000]) = 0bin0);
-ASSERT((X[0bin011001010001] & Y[0bin011001010001]) = 0bin0);
-ASSERT((X[0bin011001010010] & Y[0bin011001010010]) = 0bin0);
-ASSERT((X[0bin011001010011] & Y[0bin011001010011]) = 0bin0);
-ASSERT((X[0bin011001010100] & Y[0bin011001010100]) = 0bin0);
-ASSERT((X[0bin011001010101] & Y[0bin011001010101]) = 0bin0);
-ASSERT((X[0bin011001010110] & Y[0bin011001010110]) = 0bin0);
-ASSERT((X[0bin011001010111] & Y[0bin011001010111]) = 0bin0);
-ASSERT((X[0bin011001011000] & Y[0bin011001011000]) = 0bin0);
-ASSERT((X[0bin011001011001] & Y[0bin011001011001]) = 0bin0);
-ASSERT((X[0bin011001011010] & Y[0bin011001011010]) = 0bin0);
-ASSERT((X[0bin011001011011] & Y[0bin011001011011]) = 0bin0);
-ASSERT((X[0bin011001011100] & Y[0bin011001011100]) = 0bin0);
-ASSERT((X[0bin011001011101] & Y[0bin011001011101]) = 0bin0);
-ASSERT((X[0bin011001011110] & Y[0bin011001011110]) = 0bin0);
-ASSERT((X[0bin011001011111] & Y[0bin011001011111]) = 0bin0);
-ASSERT((X[0bin011001100000] & Y[0bin011001100000]) = 0bin0);
-ASSERT((X[0bin011001100001] & Y[0bin011001100001]) = 0bin0);
-ASSERT((X[0bin011001100010] & Y[0bin011001100010]) = 0bin0);
-ASSERT((X[0bin011001100011] & Y[0bin011001100011]) = 0bin0);
-ASSERT((X[0bin011001100100] & Y[0bin011001100100]) = 0bin0);
-ASSERT((X[0bin011001100101] & Y[0bin011001100101]) = 0bin0);
-ASSERT((X[0bin011001100110] & Y[0bin011001100110]) = 0bin0);
-ASSERT((X[0bin011001100111] & Y[0bin011001100111]) = 0bin0);
-ASSERT((X[0bin011001101000] & Y[0bin011001101000]) = 0bin0);
-ASSERT((X[0bin011001101001] & Y[0bin011001101001]) = 0bin0);
-ASSERT((X[0bin011001101010] & Y[0bin011001101010]) = 0bin0);
-ASSERT((X[0bin011001101011] & Y[0bin011001101011]) = 0bin0);
-ASSERT((X[0bin011001101100] & Y[0bin011001101100]) = 0bin0);
-ASSERT((X[0bin011001101110] & Y[0bin011001101110]) = 0bin0);
-ASSERT((X[0bin011001101111] & Y[0bin011001101111]) = 0bin0);
-ASSERT((X[0bin011001110000] & Y[0bin011001110000]) = 0bin0);
-ASSERT((X[0bin011001110001] & Y[0bin011001110001]) = 0bin0);
-ASSERT((X[0bin011001110010] & Y[0bin011001110010]) = 0bin0);
-ASSERT((X[0bin011001110011] & Y[0bin011001110011]) = 0bin0);
-ASSERT((X[0bin011001110100] & Y[0bin011001110100]) = 0bin0);
-ASSERT((X[0bin011001110101] & Y[0bin011001110101]) = 0bin0);
-ASSERT((X[0bin011001110110] & Y[0bin011001110110]) = 0bin0);
-ASSERT((X[0bin011001110111] & Y[0bin011001110111]) = 0bin0);
-ASSERT((X[0bin011001111000] & Y[0bin011001111000]) = 0bin0);
-ASSERT((X[0bin011001111001] & Y[0bin011001111001]) = 0bin0);
-ASSERT((X[0bin011001111010] & Y[0bin011001111010]) = 0bin0);
-ASSERT((X[0bin011001111011] & Y[0bin011001111011]) = 0bin0);
-ASSERT((X[0bin011001111100] & Y[0bin011001111100]) = 0bin0);
-ASSERT((X[0bin011001111101] & Y[0bin011001111101]) = 0bin0);
-ASSERT((X[0bin011001111110] & Y[0bin011001111110]) = 0bin0);
-ASSERT((X[0bin011001111111] & Y[0bin011001111111]) = 0bin0);
-ASSERT((X[0bin011010000000] & Y[0bin011010000000]) = 0bin0);
-ASSERT((X[0bin011010000001] & Y[0bin011010000001]) = 0bin0);
-ASSERT((X[0bin011010000010] & Y[0bin011010000010]) = 0bin0);
-ASSERT((X[0bin011010000011] & Y[0bin011010000011]) = 0bin0);
-ASSERT((X[0bin011010000100] & Y[0bin011010000100]) = 0bin0);
-ASSERT((X[0bin011010000101] & Y[0bin011010000101]) = 0bin0);
-ASSERT((X[0bin011010000110] & Y[0bin011010000110]) = 0bin0);
-ASSERT((X[0bin011010000111] & Y[0bin011010000111]) = 0bin0);
-ASSERT((X[0bin011010001000] & Y[0bin011010001000]) = 0bin0);
-ASSERT((X[0bin011010001001] & Y[0bin011010001001]) = 0bin0);
-ASSERT((X[0bin011010001010] & Y[0bin011010001010]) = 0bin0);
-ASSERT((X[0bin011010001011] & Y[0bin011010001011]) = 0bin0);
-ASSERT((X[0bin011010001100] & Y[0bin011010001100]) = 0bin0);
-ASSERT((X[0bin011010001101] & Y[0bin011010001101]) = 0bin0);
-ASSERT((X[0bin011010001110] & Y[0bin011010001110]) = 0bin0);
-ASSERT((X[0bin011010001111] & Y[0bin011010001111]) = 0bin0);
-ASSERT((X[0bin011010010000] & Y[0bin011010010000]) = 0bin0);
-ASSERT((X[0bin011010010001] & Y[0bin011010010001]) = 0bin0);
-ASSERT((X[0bin011010010010] & Y[0bin011010010010]) = 0bin0);
-ASSERT((X[0bin011010010011] & Y[0bin011010010011]) = 0bin0);
-ASSERT((X[0bin011010010100] & Y[0bin011010010100]) = 0bin0);
-ASSERT((X[0bin011010010101] & Y[0bin011010010101]) = 0bin0);
-ASSERT((X[0bin011010010110] & Y[0bin011010010110]) = 0bin0);
-ASSERT((X[0bin011010010111] & Y[0bin011010010111]) = 0bin0);
-ASSERT((X[0bin011010011000] & Y[0bin011010011000]) = 0bin0);
-ASSERT((X[0bin011010011001] & Y[0bin011010011001]) = 0bin0);
-ASSERT((X[0bin011010011010] & Y[0bin011010011010]) = 0bin0);
-ASSERT((X[0bin011010011011] & Y[0bin011010011011]) = 0bin0);
-ASSERT((X[0bin011010011101] & Y[0bin011010011101]) = 0bin0);
-ASSERT((X[0bin011010011110] & Y[0bin011010011110]) = 0bin0);
-ASSERT((X[0bin011010011111] & Y[0bin011010011111]) = 0bin0);
-ASSERT((X[0bin011010100000] & Y[0bin011010100000]) = 0bin0);
-ASSERT((X[0bin011010100001] & Y[0bin011010100001]) = 0bin0);
-ASSERT((X[0bin011010100010] & Y[0bin011010100010]) = 0bin0);
-ASSERT((X[0bin011010100011] & Y[0bin011010100011]) = 0bin0);
-ASSERT((X[0bin011010100100] & Y[0bin011010100100]) = 0bin0);
-ASSERT((X[0bin011010100101] & Y[0bin011010100101]) = 0bin0);
-ASSERT((X[0bin011010100110] & Y[0bin011010100110]) = 0bin0);
-ASSERT((X[0bin011010100111] & Y[0bin011010100111]) = 0bin0);
-ASSERT((X[0bin011010101000] & Y[0bin011010101000]) = 0bin0);
-ASSERT((X[0bin011010101001] & Y[0bin011010101001]) = 0bin0);
-ASSERT((X[0bin011010101010] & Y[0bin011010101010]) = 0bin0);
-ASSERT((X[0bin011010101011] & Y[0bin011010101011]) = 0bin0);
-ASSERT((X[0bin011010101100] & Y[0bin011010101100]) = 0bin0);
-ASSERT((X[0bin011010101101] & Y[0bin011010101101]) = 0bin0);
-ASSERT((X[0bin011010101110] & Y[0bin011010101110]) = 0bin0);
-ASSERT((X[0bin011010101111] & Y[0bin011010101111]) = 0bin0);
-ASSERT((X[0bin011010110000] & Y[0bin011010110000]) = 0bin0);
-ASSERT((X[0bin011010110001] & Y[0bin011010110001]) = 0bin0);
-ASSERT((X[0bin011010110010] & Y[0bin011010110010]) = 0bin0);
-ASSERT((X[0bin011010110011] & Y[0bin011010110011]) = 0bin0);
-ASSERT((X[0bin011010110100] & Y[0bin011010110100]) = 0bin0);
-ASSERT((X[0bin011010110101] & Y[0bin011010110101]) = 0bin0);
-ASSERT((X[0bin011010110110] & Y[0bin011010110110]) = 0bin0);
-ASSERT((X[0bin011010110111] & Y[0bin011010110111]) = 0bin0);
-ASSERT((X[0bin011010111000] & Y[0bin011010111000]) = 0bin0);
-ASSERT((X[0bin011010111001] & Y[0bin011010111001]) = 0bin0);
-ASSERT((X[0bin011010111010] & Y[0bin011010111010]) = 0bin0);
-ASSERT((X[0bin011010111011] & Y[0bin011010111011]) = 0bin0);
-ASSERT((X[0bin011010111100] & Y[0bin011010111100]) = 0bin0);
-ASSERT((X[0bin011010111101] & Y[0bin011010111101]) = 0bin0);
-ASSERT((X[0bin011010111110] & Y[0bin011010111110]) = 0bin0);
-ASSERT((X[0bin011010111111] & Y[0bin011010111111]) = 0bin0);
-ASSERT((X[0bin011011000000] & Y[0bin011011000000]) = 0bin0);
-ASSERT((X[0bin011011000001] & Y[0bin011011000001]) = 0bin0);
-ASSERT((X[0bin011011000010] & Y[0bin011011000010]) = 0bin0);
-ASSERT((X[0bin011011000011] & Y[0bin011011000011]) = 0bin0);
-ASSERT((X[0bin011011000100] & Y[0bin011011000100]) = 0bin0);
-ASSERT((X[0bin011011000101] & Y[0bin011011000101]) = 0bin0);
-ASSERT((X[0bin011011000110] & Y[0bin011011000110]) = 0bin0);
-ASSERT((X[0bin011011000111] & Y[0bin011011000111]) = 0bin0);
-ASSERT((X[0bin011011001000] & Y[0bin011011001000]) = 0bin0);
-ASSERT((X[0bin011011001001] & Y[0bin011011001001]) = 0bin0);
-ASSERT((X[0bin011011001010] & Y[0bin011011001010]) = 0bin0);
-ASSERT((X[0bin011011001100] & Y[0bin011011001100]) = 0bin0);
-ASSERT((X[0bin011011001101] & Y[0bin011011001101]) = 0bin0);
-ASSERT((X[0bin011011001110] & Y[0bin011011001110]) = 0bin0);
-ASSERT((X[0bin011011001111] & Y[0bin011011001111]) = 0bin0);
-ASSERT((X[0bin011011010000] & Y[0bin011011010000]) = 0bin0);
-ASSERT((X[0bin011011010001] & Y[0bin011011010001]) = 0bin0);
-ASSERT((X[0bin011011010010] & Y[0bin011011010010]) = 0bin0);
-ASSERT((X[0bin011011010011] & Y[0bin011011010011]) = 0bin0);
-ASSERT((X[0bin011011010100] & Y[0bin011011010100]) = 0bin0);
-ASSERT((X[0bin011011010101] & Y[0bin011011010101]) = 0bin0);
-ASSERT((X[0bin011011010110] & Y[0bin011011010110]) = 0bin0);
-ASSERT((X[0bin011011010111] & Y[0bin011011010111]) = 0bin0);
-ASSERT((X[0bin011011011000] & Y[0bin011011011000]) = 0bin0);
-ASSERT((X[0bin011011011001] & Y[0bin011011011001]) = 0bin0);
-ASSERT((X[0bin011011011010] & Y[0bin011011011010]) = 0bin0);
-ASSERT((X[0bin011011011011] & Y[0bin011011011011]) = 0bin0);
-ASSERT((X[0bin011011011100] & Y[0bin011011011100]) = 0bin0);
-ASSERT((X[0bin011011011101] & Y[0bin011011011101]) = 0bin0);
-ASSERT((X[0bin011011011110] & Y[0bin011011011110]) = 0bin0);
-ASSERT((X[0bin011011011111] & Y[0bin011011011111]) = 0bin0);
-ASSERT((X[0bin011011100000] & Y[0bin011011100000]) = 0bin0);
-ASSERT((X[0bin011011100001] & Y[0bin011011100001]) = 0bin0);
-ASSERT((X[0bin011011100010] & Y[0bin011011100010]) = 0bin0);
-ASSERT((X[0bin011011100011] & Y[0bin011011100011]) = 0bin0);
-ASSERT((X[0bin011011100100] & Y[0bin011011100100]) = 0bin0);
-ASSERT((X[0bin011011100101] & Y[0bin011011100101]) = 0bin0);
-ASSERT((X[0bin011011100110] & Y[0bin011011100110]) = 0bin0);
-ASSERT((X[0bin011011100111] & Y[0bin011011100111]) = 0bin0);
-ASSERT((X[0bin011011101000] & Y[0bin011011101000]) = 0bin0);
-ASSERT((X[0bin011011101001] & Y[0bin011011101001]) = 0bin0);
-ASSERT((X[0bin011011101010] & Y[0bin011011101010]) = 0bin0);
-ASSERT((X[0bin011011101011] & Y[0bin011011101011]) = 0bin0);
-ASSERT((X[0bin011011101100] & Y[0bin011011101100]) = 0bin0);
-ASSERT((X[0bin011011101101] & Y[0bin011011101101]) = 0bin0);
-ASSERT((X[0bin011011101110] & Y[0bin011011101110]) = 0bin0);
-ASSERT((X[0bin011011101111] & Y[0bin011011101111]) = 0bin0);
-ASSERT((X[0bin011011110000] & Y[0bin011011110000]) = 0bin0);
-ASSERT((X[0bin011011110001] & Y[0bin011011110001]) = 0bin0);
-ASSERT((X[0bin011011110010] & Y[0bin011011110010]) = 0bin0);
-ASSERT((X[0bin011011110011] & Y[0bin011011110011]) = 0bin0);
-ASSERT((X[0bin011011110100] & Y[0bin011011110100]) = 0bin0);
-ASSERT((X[0bin011011110101] & Y[0bin011011110101]) = 0bin0);
-ASSERT((X[0bin011011110110] & Y[0bin011011110110]) = 0bin0);
-ASSERT((X[0bin011011110111] & Y[0bin011011110111]) = 0bin0);
-ASSERT((X[0bin011011111000] & Y[0bin011011111000]) = 0bin0);
-ASSERT((X[0bin011011111001] & Y[0bin011011111001]) = 0bin0);
-ASSERT((X[0bin011011111011] & Y[0bin011011111011]) = 0bin0);
-ASSERT((X[0bin011011111100] & Y[0bin011011111100]) = 0bin0);
-ASSERT((X[0bin011011111101] & Y[0bin011011111101]) = 0bin0);
-ASSERT((X[0bin011011111110] & Y[0bin011011111110]) = 0bin0);
-ASSERT((X[0bin011011111111] & Y[0bin011011111111]) = 0bin0);
-ASSERT((X[0bin011100000000] & Y[0bin011100000000]) = 0bin0);
-ASSERT((X[0bin011100000001] & Y[0bin011100000001]) = 0bin0);
-ASSERT((X[0bin011100000010] & Y[0bin011100000010]) = 0bin0);
-ASSERT((X[0bin011100000011] & Y[0bin011100000011]) = 0bin0);
-ASSERT((X[0bin011100000100] & Y[0bin011100000100]) = 0bin0);
-ASSERT((X[0bin011100000101] & Y[0bin011100000101]) = 0bin0);
-ASSERT((X[0bin011100000110] & Y[0bin011100000110]) = 0bin0);
-ASSERT((X[0bin011100000111] & Y[0bin011100000111]) = 0bin0);
-ASSERT((X[0bin011100001000] & Y[0bin011100001000]) = 0bin0);
-ASSERT((X[0bin011100001001] & Y[0bin011100001001]) = 0bin0);
-ASSERT((X[0bin011100001010] & Y[0bin011100001010]) = 0bin0);
-ASSERT((X[0bin011100001011] & Y[0bin011100001011]) = 0bin0);
-ASSERT((X[0bin011100001100] & Y[0bin011100001100]) = 0bin0);
-ASSERT((X[0bin011100001101] & Y[0bin011100001101]) = 0bin0);
-ASSERT((X[0bin011100001110] & Y[0bin011100001110]) = 0bin0);
-ASSERT((X[0bin011100001111] & Y[0bin011100001111]) = 0bin0);
-ASSERT((X[0bin011100010000] & Y[0bin011100010000]) = 0bin0);
-ASSERT((X[0bin011100010001] & Y[0bin011100010001]) = 0bin0);
-ASSERT((X[0bin011100010010] & Y[0bin011100010010]) = 0bin0);
-ASSERT((X[0bin011100010011] & Y[0bin011100010011]) = 0bin0);
-ASSERT((X[0bin011100010100] & Y[0bin011100010100]) = 0bin0);
-ASSERT((X[0bin011100010101] & Y[0bin011100010101]) = 0bin0);
-ASSERT((X[0bin011100010110] & Y[0bin011100010110]) = 0bin0);
-ASSERT((X[0bin011100010111] & Y[0bin011100010111]) = 0bin0);
-ASSERT((X[0bin011100011000] & Y[0bin011100011000]) = 0bin0);
-ASSERT((X[0bin011100011001] & Y[0bin011100011001]) = 0bin0);
-ASSERT((X[0bin011100011010] & Y[0bin011100011010]) = 0bin0);
-ASSERT((X[0bin011100011011] & Y[0bin011100011011]) = 0bin0);
-ASSERT((X[0bin011100011100] & Y[0bin011100011100]) = 0bin0);
-ASSERT((X[0bin011100011101] & Y[0bin011100011101]) = 0bin0);
-ASSERT((X[0bin011100011110] & Y[0bin011100011110]) = 0bin0);
-ASSERT((X[0bin011100011111] & Y[0bin011100011111]) = 0bin0);
-ASSERT((X[0bin011100100000] & Y[0bin011100100000]) = 0bin0);
-ASSERT((X[0bin011100100001] & Y[0bin011100100001]) = 0bin0);
-ASSERT((X[0bin011100100010] & Y[0bin011100100010]) = 0bin0);
-ASSERT((X[0bin011100100011] & Y[0bin011100100011]) = 0bin0);
-ASSERT((X[0bin011100100100] & Y[0bin011100100100]) = 0bin0);
-ASSERT((X[0bin011100100101] & Y[0bin011100100101]) = 0bin0);
-ASSERT((X[0bin011100100110] & Y[0bin011100100110]) = 0bin0);
-ASSERT((X[0bin011100100111] & Y[0bin011100100111]) = 0bin0);
-ASSERT((X[0bin011100101000] & Y[0bin011100101000]) = 0bin0);
-ASSERT((X[0bin011100101010] & Y[0bin011100101010]) = 0bin0);
-ASSERT((X[0bin011100101011] & Y[0bin011100101011]) = 0bin0);
-ASSERT((X[0bin011100101100] & Y[0bin011100101100]) = 0bin0);
-ASSERT((X[0bin011100101101] & Y[0bin011100101101]) = 0bin0);
-ASSERT((X[0bin011100101110] & Y[0bin011100101110]) = 0bin0);
-ASSERT((X[0bin011100101111] & Y[0bin011100101111]) = 0bin0);
-ASSERT((X[0bin011100110000] & Y[0bin011100110000]) = 0bin0);
-ASSERT((X[0bin011100110001] & Y[0bin011100110001]) = 0bin0);
-ASSERT((X[0bin011100110010] & Y[0bin011100110010]) = 0bin0);
-ASSERT((X[0bin011100110011] & Y[0bin011100110011]) = 0bin0);
-ASSERT((X[0bin011100110100] & Y[0bin011100110100]) = 0bin0);
-ASSERT((X[0bin011100110101] & Y[0bin011100110101]) = 0bin0);
-ASSERT((X[0bin011100110110] & Y[0bin011100110110]) = 0bin0);
-ASSERT((X[0bin011100110111] & Y[0bin011100110111]) = 0bin0);
-ASSERT((X[0bin011100111000] & Y[0bin011100111000]) = 0bin0);
-ASSERT((X[0bin011100111001] & Y[0bin011100111001]) = 0bin0);
-ASSERT((X[0bin011100111010] & Y[0bin011100111010]) = 0bin0);
-ASSERT((X[0bin011100111011] & Y[0bin011100111011]) = 0bin0);
-ASSERT((X[0bin011100111100] & Y[0bin011100111100]) = 0bin0);
-ASSERT((X[0bin011100111101] & Y[0bin011100111101]) = 0bin0);
-ASSERT((X[0bin011100111110] & Y[0bin011100111110]) = 0bin0);
-ASSERT((X[0bin011100111111] & Y[0bin011100111111]) = 0bin0);
-ASSERT((X[0bin011101000000] & Y[0bin011101000000]) = 0bin0);
-ASSERT((X[0bin011101000001] & Y[0bin011101000001]) = 0bin0);
-ASSERT((X[0bin011101000010] & Y[0bin011101000010]) = 0bin0);
-ASSERT((X[0bin011101000011] & Y[0bin011101000011]) = 0bin0);
-ASSERT((X[0bin011101000100] & Y[0bin011101000100]) = 0bin0);
-ASSERT((X[0bin011101000101] & Y[0bin011101000101]) = 0bin0);
-ASSERT((X[0bin011101000110] & Y[0bin011101000110]) = 0bin0);
-ASSERT((X[0bin011101000111] & Y[0bin011101000111]) = 0bin0);
-ASSERT((X[0bin011101001000] & Y[0bin011101001000]) = 0bin0);
-ASSERT((X[0bin011101001001] & Y[0bin011101001001]) = 0bin0);
-ASSERT((X[0bin011101001010] & Y[0bin011101001010]) = 0bin0);
-ASSERT((X[0bin011101001011] & Y[0bin011101001011]) = 0bin0);
-ASSERT((X[0bin011101001100] & Y[0bin011101001100]) = 0bin0);
-ASSERT((X[0bin011101001101] & Y[0bin011101001101]) = 0bin0);
-ASSERT((X[0bin011101001110] & Y[0bin011101001110]) = 0bin0);
-ASSERT((X[0bin011101001111] & Y[0bin011101001111]) = 0bin0);
-ASSERT((X[0bin011101010000] & Y[0bin011101010000]) = 0bin0);
-ASSERT((X[0bin011101010001] & Y[0bin011101010001]) = 0bin0);
-ASSERT((X[0bin011101010010] & Y[0bin011101010010]) = 0bin0);
-ASSERT((X[0bin011101010011] & Y[0bin011101010011]) = 0bin0);
-ASSERT((X[0bin011101010100] & Y[0bin011101010100]) = 0bin0);
-ASSERT((X[0bin011101010101] & Y[0bin011101010101]) = 0bin0);
-ASSERT((X[0bin011101010110] & Y[0bin011101010110]) = 0bin0);
-ASSERT((X[0bin011101010111] & Y[0bin011101010111]) = 0bin0);
-ASSERT((X[0bin011101011001] & Y[0bin011101011001]) = 0bin0);
-ASSERT((X[0bin011101011010] & Y[0bin011101011010]) = 0bin0);
-ASSERT((X[0bin011101011011] & Y[0bin011101011011]) = 0bin0);
-ASSERT((X[0bin011101011100] & Y[0bin011101011100]) = 0bin0);
-ASSERT((X[0bin011101011101] & Y[0bin011101011101]) = 0bin0);
-ASSERT((X[0bin011101011110] & Y[0bin011101011110]) = 0bin0);
-ASSERT((X[0bin011101011111] & Y[0bin011101011111]) = 0bin0);
-ASSERT((X[0bin011101100000] & Y[0bin011101100000]) = 0bin0);
-ASSERT((X[0bin011101100001] & Y[0bin011101100001]) = 0bin0);
-ASSERT((X[0bin011101100010] & Y[0bin011101100010]) = 0bin0);
-ASSERT((X[0bin011101100011] & Y[0bin011101100011]) = 0bin0);
-ASSERT((X[0bin011101100100] & Y[0bin011101100100]) = 0bin0);
-ASSERT((X[0bin011101100101] & Y[0bin011101100101]) = 0bin0);
-ASSERT((X[0bin011101100110] & Y[0bin011101100110]) = 0bin0);
-ASSERT((X[0bin011101100111] & Y[0bin011101100111]) = 0bin0);
-ASSERT((X[0bin011101101000] & Y[0bin011101101000]) = 0bin0);
-ASSERT((X[0bin011101101001] & Y[0bin011101101001]) = 0bin0);
-ASSERT((X[0bin011101101010] & Y[0bin011101101010]) = 0bin0);
-ASSERT((X[0bin011101101011] & Y[0bin011101101011]) = 0bin0);
-ASSERT((X[0bin011101101100] & Y[0bin011101101100]) = 0bin0);
-ASSERT((X[0bin011101101101] & Y[0bin011101101101]) = 0bin0);
-ASSERT((X[0bin011101101110] & Y[0bin011101101110]) = 0bin0);
-ASSERT((X[0bin011101101111] & Y[0bin011101101111]) = 0bin0);
-ASSERT((X[0bin011101110000] & Y[0bin011101110000]) = 0bin0);
-ASSERT((X[0bin011101110001] & Y[0bin011101110001]) = 0bin0);
-ASSERT((X[0bin011101110010] & Y[0bin011101110010]) = 0bin0);
-ASSERT((X[0bin011101110011] & Y[0bin011101110011]) = 0bin0);
-ASSERT((X[0bin011101110100] & Y[0bin011101110100]) = 0bin0);
-ASSERT((X[0bin011101110101] & Y[0bin011101110101]) = 0bin0);
-ASSERT((X[0bin011101110110] & Y[0bin011101110110]) = 0bin0);
-ASSERT((X[0bin011101110111] & Y[0bin011101110111]) = 0bin0);
-ASSERT((X[0bin011101111000] & Y[0bin011101111000]) = 0bin0);
-ASSERT((X[0bin011101111001] & Y[0bin011101111001]) = 0bin0);
-ASSERT((X[0bin011101111010] & Y[0bin011101111010]) = 0bin0);
-ASSERT((X[0bin011101111011] & Y[0bin011101111011]) = 0bin0);
-ASSERT((X[0bin011101111100] & Y[0bin011101111100]) = 0bin0);
-ASSERT((X[0bin011101111101] & Y[0bin011101111101]) = 0bin0);
-ASSERT((X[0bin011101111110] & Y[0bin011101111110]) = 0bin0);
-ASSERT((X[0bin011101111111] & Y[0bin011101111111]) = 0bin0);
-ASSERT((X[0bin011110000000] & Y[0bin011110000000]) = 0bin0);
-ASSERT((X[0bin011110000001] & Y[0bin011110000001]) = 0bin0);
-ASSERT((X[0bin011110000010] & Y[0bin011110000010]) = 0bin0);
-ASSERT((X[0bin011110000011] & Y[0bin011110000011]) = 0bin0);
-ASSERT((X[0bin011110000100] & Y[0bin011110000100]) = 0bin0);
-ASSERT((X[0bin011110000101] & Y[0bin011110000101]) = 0bin0);
-ASSERT((X[0bin011110000110] & Y[0bin011110000110]) = 0bin0);
-ASSERT((X[0bin011110001000] & Y[0bin011110001000]) = 0bin0);
-ASSERT((X[0bin011110001001] & Y[0bin011110001001]) = 0bin0);
-ASSERT((X[0bin011110001010] & Y[0bin011110001010]) = 0bin0);
-ASSERT((X[0bin011110001011] & Y[0bin011110001011]) = 0bin0);
-ASSERT((X[0bin011110001100] & Y[0bin011110001100]) = 0bin0);
-ASSERT((X[0bin011110001101] & Y[0bin011110001101]) = 0bin0);
-ASSERT((X[0bin011110001110] & Y[0bin011110001110]) = 0bin0);
-ASSERT((X[0bin011110001111] & Y[0bin011110001111]) = 0bin0);
-ASSERT((X[0bin011110010000] & Y[0bin011110010000]) = 0bin0);
-ASSERT((X[0bin011110010001] & Y[0bin011110010001]) = 0bin0);
-ASSERT((X[0bin011110010010] & Y[0bin011110010010]) = 0bin0);
-ASSERT((X[0bin011110010011] & Y[0bin011110010011]) = 0bin0);
-ASSERT((X[0bin011110010100] & Y[0bin011110010100]) = 0bin0);
-ASSERT((X[0bin011110010101] & Y[0bin011110010101]) = 0bin0);
-ASSERT((X[0bin011110010110] & Y[0bin011110010110]) = 0bin0);
-ASSERT((X[0bin011110010111] & Y[0bin011110010111]) = 0bin0);
-ASSERT((X[0bin011110011000] & Y[0bin011110011000]) = 0bin0);
-ASSERT((X[0bin011110011001] & Y[0bin011110011001]) = 0bin0);
-ASSERT((X[0bin011110011010] & Y[0bin011110011010]) = 0bin0);
-ASSERT((X[0bin011110011011] & Y[0bin011110011011]) = 0bin0);
-ASSERT((X[0bin011110011100] & Y[0bin011110011100]) = 0bin0);
-ASSERT((X[0bin011110011101] & Y[0bin011110011101]) = 0bin0);
-ASSERT((X[0bin011110011110] & Y[0bin011110011110]) = 0bin0);
-ASSERT((X[0bin011110011111] & Y[0bin011110011111]) = 0bin0);
-ASSERT((X[0bin011110100000] & Y[0bin011110100000]) = 0bin0);
-ASSERT((X[0bin011110100001] & Y[0bin011110100001]) = 0bin0);
-ASSERT((X[0bin011110100010] & Y[0bin011110100010]) = 0bin0);
-ASSERT((X[0bin011110100011] & Y[0bin011110100011]) = 0bin0);
-ASSERT((X[0bin011110100100] & Y[0bin011110100100]) = 0bin0);
-ASSERT((X[0bin011110100101] & Y[0bin011110100101]) = 0bin0);
-ASSERT((X[0bin011110100110] & Y[0bin011110100110]) = 0bin0);
-ASSERT((X[0bin011110100111] & Y[0bin011110100111]) = 0bin0);
-ASSERT((X[0bin011110101000] & Y[0bin011110101000]) = 0bin0);
-ASSERT((X[0bin011110101001] & Y[0bin011110101001]) = 0bin0);
-ASSERT((X[0bin011110101010] & Y[0bin011110101010]) = 0bin0);
-ASSERT((X[0bin011110101011] & Y[0bin011110101011]) = 0bin0);
-ASSERT((X[0bin011110101100] & Y[0bin011110101100]) = 0bin0);
-ASSERT((X[0bin011110101101] & Y[0bin011110101101]) = 0bin0);
-ASSERT((X[0bin011110101110] & Y[0bin011110101110]) = 0bin0);
-ASSERT((X[0bin011110101111] & Y[0bin011110101111]) = 0bin0);
-ASSERT((X[0bin011110110000] & Y[0bin011110110000]) = 0bin0);
-ASSERT((X[0bin011110110001] & Y[0bin011110110001]) = 0bin0);
-ASSERT((X[0bin011110110010] & Y[0bin011110110010]) = 0bin0);
-ASSERT((X[0bin011110110011] & Y[0bin011110110011]) = 0bin0);
-ASSERT((X[0bin011110110100] & Y[0bin011110110100]) = 0bin0);
-ASSERT((X[0bin011110110101] & Y[0bin011110110101]) = 0bin0);
-ASSERT((X[0bin011110110111] & Y[0bin011110110111]) = 0bin0);
-ASSERT((X[0bin011110111000] & Y[0bin011110111000]) = 0bin0);
-ASSERT((X[0bin011110111001] & Y[0bin011110111001]) = 0bin0);
-ASSERT((X[0bin011110111010] & Y[0bin011110111010]) = 0bin0);
-ASSERT((X[0bin011110111011] & Y[0bin011110111011]) = 0bin0);
-ASSERT((X[0bin011110111100] & Y[0bin011110111100]) = 0bin0);
-ASSERT((X[0bin011110111101] & Y[0bin011110111101]) = 0bin0);
-ASSERT((X[0bin011110111110] & Y[0bin011110111110]) = 0bin0);
-ASSERT((X[0bin011110111111] & Y[0bin011110111111]) = 0bin0);
-ASSERT((X[0bin011111000000] & Y[0bin011111000000]) = 0bin0);
-ASSERT((X[0bin011111000001] & Y[0bin011111000001]) = 0bin0);
-ASSERT((X[0bin011111000010] & Y[0bin011111000010]) = 0bin0);
-ASSERT((X[0bin011111000011] & Y[0bin011111000011]) = 0bin0);
-ASSERT((X[0bin011111000100] & Y[0bin011111000100]) = 0bin0);
-ASSERT((X[0bin011111000101] & Y[0bin011111000101]) = 0bin0);
-ASSERT((X[0bin011111000110] & Y[0bin011111000110]) = 0bin0);
-ASSERT((X[0bin011111000111] & Y[0bin011111000111]) = 0bin0);
-ASSERT((X[0bin011111001000] & Y[0bin011111001000]) = 0bin0);
-ASSERT((X[0bin011111001001] & Y[0bin011111001001]) = 0bin0);
-ASSERT((X[0bin011111001010] & Y[0bin011111001010]) = 0bin0);
-ASSERT((X[0bin011111001011] & Y[0bin011111001011]) = 0bin0);
-ASSERT((X[0bin011111001100] & Y[0bin011111001100]) = 0bin0);
-ASSERT((X[0bin011111001101] & Y[0bin011111001101]) = 0bin0);
-ASSERT((X[0bin011111001110] & Y[0bin011111001110]) = 0bin0);
-ASSERT((X[0bin011111001111] & Y[0bin011111001111]) = 0bin0);
-ASSERT((X[0bin011111010000] & Y[0bin011111010000]) = 0bin0);
-ASSERT((X[0bin011111010001] & Y[0bin011111010001]) = 0bin0);
-ASSERT((X[0bin011111010010] & Y[0bin011111010010]) = 0bin0);
-ASSERT((X[0bin011111010011] & Y[0bin011111010011]) = 0bin0);
-ASSERT((X[0bin011111010100] & Y[0bin011111010100]) = 0bin0);
-ASSERT((X[0bin011111010101] & Y[0bin011111010101]) = 0bin0);
-ASSERT((X[0bin011111010110] & Y[0bin011111010110]) = 0bin0);
-ASSERT((X[0bin011111010111] & Y[0bin011111010111]) = 0bin0);
-ASSERT((X[0bin011111011000] & Y[0bin011111011000]) = 0bin0);
-ASSERT((X[0bin011111011001] & Y[0bin011111011001]) = 0bin0);
-ASSERT((X[0bin011111011010] & Y[0bin011111011010]) = 0bin0);
-ASSERT((X[0bin011111011011] & Y[0bin011111011011]) = 0bin0);
-ASSERT((X[0bin011111011100] & Y[0bin011111011100]) = 0bin0);
-ASSERT((X[0bin011111011101] & Y[0bin011111011101]) = 0bin0);
-ASSERT((X[0bin011111011110] & Y[0bin011111011110]) = 0bin0);
-ASSERT((X[0bin011111011111] & Y[0bin011111011111]) = 0bin0);
-ASSERT((X[0bin011111100000] & Y[0bin011111100000]) = 0bin0);
-ASSERT((X[0bin011111100001] & Y[0bin011111100001]) = 0bin0);
-ASSERT((X[0bin011111100010] & Y[0bin011111100010]) = 0bin0);
-ASSERT((X[0bin011111100011] & Y[0bin011111100011]) = 0bin0);
-ASSERT((X[0bin011111100100] & Y[0bin011111100100]) = 0bin0);
-ASSERT((X[0bin011111100110] & Y[0bin011111100110]) = 0bin0);
-ASSERT((X[0bin011111100111] & Y[0bin011111100111]) = 0bin0);
-ASSERT((X[0bin011111101000] & Y[0bin011111101000]) = 0bin0);
-ASSERT((X[0bin011111101001] & Y[0bin011111101001]) = 0bin0);
-ASSERT((X[0bin011111101010] & Y[0bin011111101010]) = 0bin0);
-ASSERT((X[0bin011111101011] & Y[0bin011111101011]) = 0bin0);
-ASSERT((X[0bin011111101100] & Y[0bin011111101100]) = 0bin0);
-ASSERT((X[0bin011111101101] & Y[0bin011111101101]) = 0bin0);
-ASSERT((X[0bin011111101110] & Y[0bin011111101110]) = 0bin0);
-ASSERT((X[0bin011111101111] & Y[0bin011111101111]) = 0bin0);
-ASSERT((X[0bin011111110000] & Y[0bin011111110000]) = 0bin0);
-ASSERT((X[0bin011111110001] & Y[0bin011111110001]) = 0bin0);
-ASSERT((X[0bin011111110010] & Y[0bin011111110010]) = 0bin0);
-ASSERT((X[0bin011111110011] & Y[0bin011111110011]) = 0bin0);
-ASSERT((X[0bin011111110100] & Y[0bin011111110100]) = 0bin0);
-ASSERT((X[0bin011111110101] & Y[0bin011111110101]) = 0bin0);
-ASSERT((X[0bin011111110110] & Y[0bin011111110110]) = 0bin0);
-ASSERT((X[0bin011111110111] & Y[0bin011111110111]) = 0bin0);
-ASSERT((X[0bin011111111000] & Y[0bin011111111000]) = 0bin0);
-ASSERT((X[0bin011111111001] & Y[0bin011111111001]) = 0bin0);
-ASSERT((X[0bin011111111010] & Y[0bin011111111010]) = 0bin0);
-ASSERT((X[0bin011111111011] & Y[0bin011111111011]) = 0bin0);
-ASSERT((X[0bin011111111100] & Y[0bin011111111100]) = 0bin0);
-ASSERT((X[0bin011111111101] & Y[0bin011111111101]) = 0bin0);
-ASSERT((X[0bin011111111110] & Y[0bin011111111110]) = 0bin0);
-ASSERT((X[0bin011111111111] & Y[0bin011111111111]) = 0bin0);
-ASSERT((X[0bin100000000000] & Y[0bin100000000000]) = 0bin0);
-ASSERT((X[0bin100000000001] & Y[0bin100000000001]) = 0bin0);
-ASSERT((X[0bin100000000010] & Y[0bin100000000010]) = 0bin0);
-ASSERT((X[0bin100000000011] & Y[0bin100000000011]) = 0bin0);
-ASSERT((X[0bin100000000100] & Y[0bin100000000100]) = 0bin0);
-ASSERT((X[0bin100000000101] & Y[0bin100000000101]) = 0bin0);
-ASSERT((X[0bin100000000110] & Y[0bin100000000110]) = 0bin0);
-ASSERT((X[0bin100000000111] & Y[0bin100000000111]) = 0bin0);
-ASSERT((X[0bin100000001000] & Y[0bin100000001000]) = 0bin0);
-ASSERT((X[0bin100000001001] & Y[0bin100000001001]) = 0bin0);
-ASSERT((X[0bin100000001010] & Y[0bin100000001010]) = 0bin0);
-ASSERT((X[0bin100000001011] & Y[0bin100000001011]) = 0bin0);
-ASSERT((X[0bin100000001100] & Y[0bin100000001100]) = 0bin0);
-ASSERT((X[0bin100000001101] & Y[0bin100000001101]) = 0bin0);
-ASSERT((X[0bin100000001110] & Y[0bin100000001110]) = 0bin0);
-ASSERT((X[0bin100000001111] & Y[0bin100000001111]) = 0bin0);
-ASSERT((X[0bin100000010000] & Y[0bin100000010000]) = 0bin0);
-ASSERT((X[0bin100000010001] & Y[0bin100000010001]) = 0bin0);
-ASSERT((X[0bin100000010010] & Y[0bin100000010010]) = 0bin0);
-ASSERT((X[0bin100000010011] & Y[0bin100000010011]) = 0bin0);
-ASSERT((X[0bin100000010101] & Y[0bin100000010101]) = 0bin0);
-ASSERT((X[0bin100000010110] & Y[0bin100000010110]) = 0bin0);
-ASSERT((X[0bin100000010111] & Y[0bin100000010111]) = 0bin0);
-ASSERT((X[0bin100000011000] & Y[0bin100000011000]) = 0bin0);
-ASSERT((X[0bin100000011001] & Y[0bin100000011001]) = 0bin0);
-ASSERT((X[0bin100000011010] & Y[0bin100000011010]) = 0bin0);
-ASSERT((X[0bin100000011011] & Y[0bin100000011011]) = 0bin0);
-ASSERT((X[0bin100000011100] & Y[0bin100000011100]) = 0bin0);
-ASSERT((X[0bin100000011101] & Y[0bin100000011101]) = 0bin0);
-ASSERT((X[0bin100000011110] & Y[0bin100000011110]) = 0bin0);
-ASSERT((X[0bin100000011111] & Y[0bin100000011111]) = 0bin0);
-ASSERT((X[0bin100000100000] & Y[0bin100000100000]) = 0bin0);
-ASSERT((X[0bin100000100001] & Y[0bin100000100001]) = 0bin0);
-ASSERT((X[0bin100000100010] & Y[0bin100000100010]) = 0bin0);
-ASSERT((X[0bin100000100011] & Y[0bin100000100011]) = 0bin0);
-ASSERT((X[0bin100000100100] & Y[0bin100000100100]) = 0bin0);
-ASSERT((X[0bin100000100101] & Y[0bin100000100101]) = 0bin0);
-ASSERT((X[0bin100000100110] & Y[0bin100000100110]) = 0bin0);
-ASSERT((X[0bin100000100111] & Y[0bin100000100111]) = 0bin0);
-ASSERT((X[0bin100000101000] & Y[0bin100000101000]) = 0bin0);
-ASSERT((X[0bin100000101001] & Y[0bin100000101001]) = 0bin0);
-ASSERT((X[0bin100000101010] & Y[0bin100000101010]) = 0bin0);
-ASSERT((X[0bin100000101011] & Y[0bin100000101011]) = 0bin0);
-ASSERT((X[0bin100000101100] & Y[0bin100000101100]) = 0bin0);
-ASSERT((X[0bin100000101101] & Y[0bin100000101101]) = 0bin0);
-ASSERT((X[0bin100000101110] & Y[0bin100000101110]) = 0bin0);
-ASSERT((X[0bin100000101111] & Y[0bin100000101111]) = 0bin0);
-ASSERT((X[0bin100000110000] & Y[0bin100000110000]) = 0bin0);
-ASSERT((X[0bin100000110001] & Y[0bin100000110001]) = 0bin0);
-ASSERT((X[0bin100000110010] & Y[0bin100000110010]) = 0bin0);
-ASSERT((X[0bin100000110011] & Y[0bin100000110011]) = 0bin0);
-ASSERT((X[0bin100000110100] & Y[0bin100000110100]) = 0bin0);
-ASSERT((X[0bin100000110101] & Y[0bin100000110101]) = 0bin0);
-ASSERT((X[0bin100000110110] & Y[0bin100000110110]) = 0bin0);
-ASSERT((X[0bin100000110111] & Y[0bin100000110111]) = 0bin0);
-ASSERT((X[0bin100000111000] & Y[0bin100000111000]) = 0bin0);
-ASSERT((X[0bin100000111001] & Y[0bin100000111001]) = 0bin0);
-ASSERT((X[0bin100000111010] & Y[0bin100000111010]) = 0bin0);
-ASSERT((X[0bin100000111011] & Y[0bin100000111011]) = 0bin0);
-ASSERT((X[0bin100000111100] & Y[0bin100000111100]) = 0bin0);
-ASSERT((X[0bin100000111101] & Y[0bin100000111101]) = 0bin0);
-ASSERT((X[0bin100000111110] & Y[0bin100000111110]) = 0bin0);
-ASSERT((X[0bin100000111111] & Y[0bin100000111111]) = 0bin0);
-ASSERT((X[0bin100001000000] & Y[0bin100001000000]) = 0bin0);
-ASSERT((X[0bin100001000001] & Y[0bin100001000001]) = 0bin0);
-ASSERT((X[0bin100001000010] & Y[0bin100001000010]) = 0bin0);
-%%%%%%%%%% (5) %%%%%%%%%%
-ASSERT (
-FOR(i0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(j0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(k0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(l0:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001;EXCEPT BVGE(i0,k0) OR BVGE(k0,j0) OR BVGE(j0,l0)){
- LET ij = (BVPLUS(12, BVMULT(12, i0,0bin000000101110), j0)) IN
- LET kl = (BVPLUS(12, BVMULT(12, k0,0bin000000101110), l0)) IN
- X[ij] & X[kl] = 0bin0
-} } } } );
-%%%%%%%%%% (6) %%%%%%%%%%
-ASSERT (
-FOR(i1:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(j1:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(k1:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001){
-FOR(l1:BITVECTOR(12);0bin000000000000;0bin000000101110;0bin000000000001;EXCEPT BVGE(i1,k1) OR BVGE(k1,j1) OR BVGE(j1,l1)){
- LET ij = (BVPLUS(12, BVMULT(12, i1,0bin000000101110), j1)) IN
- LET kl = (BVPLUS(12, BVMULT(12, k1,0bin000000101110), l1)) IN
- Y[ij] & Y[kl] = 0bin0
-} } } } );
-
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Objective function
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-total_energy : BITVECTOR(16);
-ASSERT(total_energy = BVPLUS(16,0bin00000000@final_Ex[0bin000000000111], 0bin00000000@final_Ey[0bin000000000111],0bin00000000@final_Ex[0bin000000010000], 0bin00000000@final_Ey[0bin000000010000],0bin00000000@final_Ex[0bin000000010010], 0bin00000000@final_Ey[0bin000000010010],0bin00000000@final_Ex[0bin000000010110], 0bin00000000@final_Ey[0bin000000010110],0bin00000000@final_Ex[0bin000000011001], 0bin00000000@final_Ey[0bin000000011001],0bin00000000@final_Ex[0bin000000011100], 0bin00000000@final_Ey[0bin000000011100],0bin00000000@final_Ex[0bin000000011111], 0bin00000000@final_Ey[0bin000000011111],0bin00000000@final_Ex[0bin000000101011], 0bin00000000@final_Ey[0bin000000101011],0bin00000000@final_Ex[0bin000000101101], 0bin00000000@final_Ey[0bin000000101101],0bin00000000@final_Ex[0bin000000111111], 0bin00000000@final_Ey[0bin000000111111],0bin00000000@final_Ex[0bin000001011010], 0bin00000000@final_Ey[0bin000001011010],0bin00000000@final_Ex[0bin000001101100], 0bin00000000@final_Ey[0bin000001101100],0bin00000000@final_Ex[0bin000001111011], 0bin00000000@final_Ey[0bin000001111011],0bin00000000@final_Ex[0bin000010000111], 0bin00000000@final_Ey[0bin000010000111],0bin00000000@final_Ex[0bin000010010000], 0bin00000000@final_Ey[0bin000010010000],0bin00000000@final_Ex[0bin000010101000], 0bin00000000@final_Ey[0bin000010101000],0bin00000000@final_Ex[0bin000010110000], 0bin00000000@final_Ey[0bin000010110000],0bin00000000@final_Ex[0bin000010110011], 0bin00000000@final_Ey[0bin000010110011],0bin00000000@final_Ex[0bin000010110100], 0bin00000000@final_Ey[0bin000010110100],0bin00000000@final_Ex[0bin000011000111], 0bin00000000@final_Ey[0bin000011000111],0bin00000000@final_Ex[0bin000011001001], 0bin00000000@final_Ey[0bin000011001001],0bin00000000@final_Ex[0bin000011010011], 0bin00000000@final_Ey[0bin000011010011],0bin00000000@final_Ex[0bin000011010101], 0bin00000000@final_Ey[0bin000011010101],0bin00000000@final_Ex[0bin000011011101], 0bin00000000@final_Ey[0bin000011011101],0bin00000000@final_Ex[0bin000011100100], 0bin00000000@final_Ey[0bin000011100100],0bin00000000@final_Ex[0bin000011101010], 0bin00000000@final_Ey[0bin000011101010],0bin00000000@final_Ex[0bin000011101110], 0bin00000000@final_Ey[0bin000011101110],0bin00000000@final_Ex[0bin000011110010], 0bin00000000@final_Ey[0bin000011110010],0bin00000000@final_Ex[0bin000011110011], 0bin00000000@final_Ey[0bin000011110011],0bin00000000@final_Ex[0bin000011110100], 0bin00000000@final_Ey[0bin000011110100],0bin00000000@final_Ex[0bin000011111001], 0bin00000000@final_Ey[0bin000011111001],0bin00000000@final_Ex[0bin000100000000], 0bin00000000@final_Ey[0bin000100000000],0bin00000000@final_Ex[0bin000100010101], 0bin00000000@final_Ey[0bin000100010101],0bin00000000@final_Ex[0bin000100100100], 0bin00000000@final_Ey[0bin000100100100],0bin00000000@final_Ex[0bin000100100110], 0bin00000000@final_Ey[0bin000100100110],0bin00000000@final_Ex[0bin000100101010], 0bin00000000@final_Ey[0bin000100101010],0bin00000000@final_Ex[0bin000100101101], 0bin00000000@final_Ey[0bin000100101101],0bin00000000@final_Ex[0bin000100110000], 0bin00000000@final_Ey[0bin000100110000],0bin00000000@final_Ex[0bin000100110011], 0bin00000000@final_Ey[0bin000100110011],0bin00000000@final_Ex[0bin000100111111], 0bin00000000@final_Ey[0bin000100111111],0bin00000000@final_Ex[0bin000101000001], 0bin00000000@final_Ey[0bin000101000001],0bin00000000@final_Ex[0bin000101001000], 0bin00000000@final_Ey[0bin000101001000],0bin00000000@final_Ex[0bin000101010111], 0bin00000000@final_Ey[0bin000101010111],0bin00000000@final_Ex[0bin000101011010], 0bin00000000@final_Ey[0bin000101011010],0bin00000000@final_Ex[0bin000101100000], 0bin00000000@final_Ey[0bin000101100000],0bin00000000@final_Ex[0bin000101101000], 0bin00000000@final_Ey[0bin000101101000],0bin00000000@final_Ex[0bin000101101010], 0bin00000000@final_Ey[0bin000101101010],0bin00000000@final_Ex[0bin000101101011], 0bin00000000@final_Ey[0bin000101101011],0bin00000000@final_Ex[0bin000101101100], 0bin00000000@final_Ey[0bin000101101100],0bin00000000@final_Ex[0bin000110000001], 0bin00000000@final_Ey[0bin000110000001],0bin00000000@final_Ex[0bin000110010000], 0bin00000000@final_Ey[0bin000110010000],0bin00000000@final_Ex[0bin000110010011], 0bin00000000@final_Ey[0bin000110010011],0bin00000000@final_Ex[0bin000110011100], 0bin00000000@final_Ey[0bin000110011100],0bin00000000@final_Ex[0bin000111011100], 0bin00000000@final_Ey[0bin000111011100],0bin00000000@final_Ex[0bin000111101011], 0bin00000000@final_Ey[0bin000111101011],0bin00000000@final_Ex[0bin000111110111], 0bin00000000@final_Ey[0bin000111110111],0bin00000000@final_Ex[0bin001000000000], 0bin00000000@final_Ey[0bin001000000000],0bin00000000@final_Ex[0bin001000001111], 0bin00000000@final_Ey[0bin001000001111],0bin00000000@final_Ex[0bin001000010010], 0bin00000000@final_Ey[0bin001000010010],0bin00000000@final_Ex[0bin001000011000], 0bin00000000@final_Ey[0bin001000011000],0bin00000000@final_Ex[0bin001000100000], 0bin00000000@final_Ey[0bin001000100000],0bin00000000@final_Ex[0bin001000100010], 0bin00000000@final_Ey[0bin001000100010],0bin00000000@final_Ex[0bin001000100011], 0bin00000000@final_Ey[0bin001000100011],0bin00000000@final_Ex[0bin001000100100], 0bin00000000@final_Ey[0bin001000100100],0bin00000000@final_Ex[0bin001000101110], 0bin00000000@final_Ey[0bin001000101110],0bin00000000@final_Ex[0bin001001000110], 0bin00000000@final_Ey[0bin001001000110],0bin00000000@final_Ex[0bin001001001110], 0bin00000000@final_Ey[0bin001001001110],0bin00000000@final_Ex[0bin001001001111], 0bin00000000@final_Ey[0bin001001001111],0bin00000000@final_Ex[0bin001001010001], 0bin00000000@final_Ey[0bin001001010001],0bin00000000@final_Ex[0bin001001010010], 0bin00000000@final_Ey[0bin001001010010],0bin00000000@final_Ex[0bin001001011100], 0bin00000000@final_Ey[0bin001001011100],0bin00000000@final_Ex[0bin001001110100], 0bin00000000@final_Ey[0bin001001110100],0bin00000000@final_Ex[0bin001001111100], 0bin00000000@final_Ey[0bin001001111100],0bin00000000@final_Ex[0bin001001111111], 0bin00000000@final_Ey[0bin001001111111],0bin00000000@final_Ex[0bin001010000000], 0bin00000000@final_Ey[0bin001010000000],0bin00000000@final_Ex[0bin001010001001], 0bin00000000@final_Ey[0bin001010001001],0bin00000000@final_Ex[0bin001010010101], 0bin00000000@final_Ey[0bin001010010101],0bin00000000@final_Ex[0bin001010011111], 0bin00000000@final_Ey[0bin001010011111],0bin00000000@final_Ex[0bin001010100001], 0bin00000000@final_Ey[0bin001010100001],0bin00000000@final_Ex[0bin001010101001], 0bin00000000@final_Ey[0bin001010101001],0bin00000000@final_Ex[0bin001010110000], 0bin00000000@final_Ey[0bin001010110000],0bin00000000@final_Ex[0bin001010110011], 0bin00000000@final_Ey[0bin001010110011],0bin00000000@final_Ex[0bin001010110101], 0bin00000000@final_Ey[0bin001010110101],0bin00000000@final_Ex[0bin001010111001], 0bin00000000@final_Ey[0bin001010111001],0bin00000000@final_Ex[0bin001010111101], 0bin00000000@final_Ey[0bin001010111101],0bin00000000@final_Ex[0bin001011000100], 0bin00000000@final_Ey[0bin001011000100],0bin00000000@final_Ex[0bin001011001000], 0bin00000000@final_Ey[0bin001011001000],0bin00000000@final_Ex[0bin001011001011], 0bin00000000@final_Ey[0bin001011001011],0bin00000000@final_Ex[0bin001011001110], 0bin00000000@final_Ey[0bin001011001110],0bin00000000@final_Ex[0bin001011010001], 0bin00000000@final_Ey[0bin001011010001],0bin00000000@final_Ex[0bin001011010100], 0bin00000000@final_Ey[0bin001011010100],0bin00000000@final_Ex[0bin001011010110], 0bin00000000@final_Ey[0bin001011010110],0bin00000000@final_Ex[0bin001011011101], 0bin00000000@final_Ey[0bin001011011101],0bin00000000@final_Ex[0bin001011011111], 0bin00000000@final_Ey[0bin001011011111],0bin00000000@final_Ex[0bin001011100010], 0bin00000000@final_Ey[0bin001011100010],0bin00000000@final_Ex[0bin001011100101], 0bin00000000@final_Ey[0bin001011100101],0bin00000000@final_Ex[0bin001011101001], 0bin00000000@final_Ey[0bin001011101001],0bin00000000@final_Ex[0bin001011101111], 0bin00000000@final_Ey[0bin001011101111],0bin00000000@final_Ex[0bin001011110100], 0bin00000000@final_Ey[0bin001011110100],0bin00000000@final_Ex[0bin001011110111], 0bin00000000@final_Ey[0bin001011110111],0bin00000000@final_Ex[0bin001011111011], 0bin00000000@final_Ey[0bin001011111011],0bin00000000@final_Ex[0bin001011111101], 0bin00000000@final_Ey[0bin001011111101],0bin00000000@final_Ex[0bin001100000000], 0bin00000000@final_Ey[0bin001100000000],0bin00000000@final_Ex[0bin001100000011], 0bin00000000@final_Ey[0bin001100000011],0bin00000000@final_Ex[0bin001100000101], 0bin00000000@final_Ey[0bin001100000101],0bin00000000@final_Ex[0bin001100001100], 0bin00000000@final_Ey[0bin001100001100],0bin00000000@final_Ex[0bin001100001111], 0bin00000000@final_Ey[0bin001100001111],0bin00000000@final_Ex[0bin001100010101], 0bin00000000@final_Ey[0bin001100010101],0bin00000000@final_Ex[0bin001100011110], 0bin00000000@final_Ey[0bin001100011110],0bin00000000@final_Ex[0bin001100100100], 0bin00000000@final_Ey[0bin001100100100],0bin00000000@final_Ex[0bin001100100111], 0bin00000000@final_Ey[0bin001100100111],0bin00000000@final_Ex[0bin001100101010], 0bin00000000@final_Ey[0bin001100101010],0bin00000000@final_Ex[0bin001100101101], 0bin00000000@final_Ey[0bin001100101101],0bin00000000@final_Ex[0bin001100111001], 0bin00000000@final_Ey[0bin001100111001],0bin00000000@final_Ex[0bin001100111011], 0bin00000000@final_Ey[0bin001100111011],0bin00000000@final_Ex[0bin001101000010], 0bin00000000@final_Ey[0bin001101000010],0bin00000000@final_Ex[0bin001101011010], 0bin00000000@final_Ey[0bin001101011010],0bin00000000@final_Ex[0bin001101100010], 0bin00000000@final_Ey[0bin001101100010],0bin00000000@final_Ex[0bin001101100101], 0bin00000000@final_Ey[0bin001101100101],0bin00000000@final_Ex[0bin001101100110], 0bin00000000@final_Ey[0bin001101100110],0bin00000000@final_Ex[0bin001101111011], 0bin00000000@final_Ey[0bin001101111011],0bin00000000@final_Ex[0bin001110010110], 0bin00000000@final_Ey[0bin001110010110],0bin00000000@final_Ex[0bin001110100000], 0bin00000000@final_Ey[0bin001110100000],0bin00000000@final_Ex[0bin001110100100], 0bin00000000@final_Ey[0bin001110100100],0bin00000000@final_Ex[0bin001111000111], 0bin00000000@final_Ey[0bin001111000111],0bin00000000@final_Ex[0bin001111001101], 0bin00000000@final_Ey[0bin001111001101],0bin00000000@final_Ex[0bin001111010110], 0bin00000000@final_Ey[0bin001111010110],0bin00000000@final_Ex[0bin001111011000], 0bin00000000@final_Ey[0bin001111011000],0bin00000000@final_Ex[0bin001111011111], 0bin00000000@final_Ey[0bin001111011111],0bin00000000@final_Ex[0bin001111100010], 0bin00000000@final_Ey[0bin001111100010],0bin00000000@final_Ex[0bin001111100101], 0bin00000000@final_Ey[0bin001111100101],0bin00000000@final_Ex[0bin001111110001], 0bin00000000@final_Ey[0bin001111110001],0bin00000000@final_Ex[0bin001111110011], 0bin00000000@final_Ey[0bin001111110011],0bin00000000@final_Ex[0bin010000000101], 0bin00000000@final_Ey[0bin010000000101],0bin00000000@final_Ex[0bin010000100000], 0bin00000000@final_Ey[0bin010000100000],0bin00000000@final_Ex[0bin010000101010], 0bin00000000@final_Ey[0bin010000101010],0bin00000000@final_Ex[0bin010000101110], 0bin00000000@final_Ey[0bin010000101110],0bin00000000@final_Ex[0bin010001010001], 0bin00000000@final_Ey[0bin010001010001],0bin00000000@final_Ex[0bin010001010111], 0bin00000000@final_Ey[0bin010001010111],0bin00000000@final_Ex[0bin010001100000], 0bin00000000@final_Ey[0bin010001100000],0bin00000000@final_Ex[0bin010001100010], 0bin00000000@final_Ey[0bin010001100010],0bin00000000@final_Ex[0bin010001100110], 0bin00000000@final_Ey[0bin010001100110],0bin00000000@final_Ex[0bin010001101100], 0bin00000000@final_Ey[0bin010001101100],0bin00000000@final_Ex[0bin010001101111], 0bin00000000@final_Ey[0bin010001101111],0bin00000000@final_Ex[0bin010001111011], 0bin00000000@final_Ey[0bin010001111011],0bin00000000@final_Ex[0bin010001111101], 0bin00000000@final_Ey[0bin010001111101],0bin00000000@final_Ex[0bin010010000100], 0bin00000000@final_Ey[0bin010010000100],0bin00000000@final_Ex[0bin010010011100], 0bin00000000@final_Ey[0bin010010011100],0bin00000000@final_Ex[0bin010010100100], 0bin00000000@final_Ey[0bin010010100100],0bin00000000@final_Ex[0bin010010100111], 0bin00000000@final_Ey[0bin010010100111],0bin00000000@final_Ex[0bin010010101000], 0bin00000000@final_Ey[0bin010010101000],0bin00000000@final_Ex[0bin010010110001], 0bin00000000@final_Ey[0bin010010110001],0bin00000000@final_Ex[0bin010010111011], 0bin00000000@final_Ey[0bin010010111011],0bin00000000@final_Ex[0bin010010111101], 0bin00000000@final_Ey[0bin010010111101],0bin00000000@final_Ex[0bin010011001001], 0bin00000000@final_Ey[0bin010011001001],0bin00000000@final_Ex[0bin010011010001], 0bin00000000@final_Ey[0bin010011010001],0bin00000000@final_Ex[0bin010011011000], 0bin00000000@final_Ey[0bin010011011000],0bin00000000@final_Ex[0bin010011011011], 0bin00000000@final_Ey[0bin010011011011],0bin00000000@final_Ex[0bin010011100001], 0bin00000000@final_Ey[0bin010011100001],0bin00000000@final_Ex[0bin010011101010], 0bin00000000@final_Ey[0bin010011101010],0bin00000000@final_Ex[0bin010011101100], 0bin00000000@final_Ey[0bin010011101100],0bin00000000@final_Ex[0bin010011110000], 0bin00000000@final_Ey[0bin010011110000],0bin00000000@final_Ex[0bin010011110011], 0bin00000000@final_Ey[0bin010011110011],0bin00000000@final_Ex[0bin010011111001], 0bin00000000@final_Ey[0bin010011111001],0bin00000000@final_Ex[0bin010100000101], 0bin00000000@final_Ey[0bin010100000101],0bin00000000@final_Ex[0bin010100000111], 0bin00000000@final_Ey[0bin010100000111],0bin00000000@final_Ex[0bin010100001101], 0bin00000000@final_Ey[0bin010100001101],0bin00000000@final_Ex[0bin010100010111], 0bin00000000@final_Ey[0bin010100010111],0bin00000000@final_Ex[0bin010100011001], 0bin00000000@final_Ey[0bin010100011001],0bin00000000@final_Ex[0bin010100100011], 0bin00000000@final_Ey[0bin010100100011],0bin00000000@final_Ex[0bin010100101101], 0bin00000000@final_Ey[0bin010100101101],0bin00000000@final_Ex[0bin010100110100], 0bin00000000@final_Ey[0bin010100110100],0bin00000000@final_Ex[0bin010100111010], 0bin00000000@final_Ey[0bin010100111010],0bin00000000@final_Ex[0bin010100111110], 0bin00000000@final_Ey[0bin010100111110],0bin00000000@final_Ex[0bin010101000010], 0bin00000000@final_Ey[0bin010101000010],0bin00000000@final_Ex[0bin010101000011], 0bin00000000@final_Ey[0bin010101000011],0bin00000000@final_Ex[0bin010101000100], 0bin00000000@final_Ey[0bin010101000100],0bin00000000@final_Ex[0bin010101001001], 0bin00000000@final_Ey[0bin010101001001],0bin00000000@final_Ex[0bin010101010000], 0bin00000000@final_Ey[0bin010101010000],0bin00000000@final_Ex[0bin010101100101], 0bin00000000@final_Ey[0bin010101100101],0bin00000000@final_Ex[0bin010101100111], 0bin00000000@final_Ey[0bin010101100111],0bin00000000@final_Ex[0bin010101101011], 0bin00000000@final_Ey[0bin010101101011],0bin00000000@final_Ex[0bin010101101111], 0bin00000000@final_Ey[0bin010101101111],0bin00000000@final_Ex[0bin010101110100], 0bin00000000@final_Ey[0bin010101110100],0bin00000000@final_Ex[0bin010101110110], 0bin00000000@final_Ey[0bin010101110110],0bin00000000@final_Ex[0bin010101111010], 0bin00000000@final_Ey[0bin010101111010],0bin00000000@final_Ex[0bin010101111101], 0bin00000000@final_Ey[0bin010101111101],0bin00000000@final_Ex[0bin010110000000], 0bin00000000@final_Ey[0bin010110000000],0bin00000000@final_Ex[0bin010110000110], 0bin00000000@final_Ey[0bin010110000110],0bin00000000@final_Ex[0bin010110001000], 0bin00000000@final_Ey[0bin010110001000],0bin00000000@final_Ex[0bin010110001111], 0bin00000000@final_Ey[0bin010110001111],0bin00000000@final_Ex[0bin010110010001], 0bin00000000@final_Ey[0bin010110010001],0bin00000000@final_Ex[0bin010110011011], 0bin00000000@final_Ey[0bin010110011011],0bin00000000@final_Ex[0bin010110100011], 0bin00000000@final_Ey[0bin010110100011],0bin00000000@final_Ex[0bin010110110101], 0bin00000000@final_Ey[0bin010110110101],0bin00000000@final_Ex[0bin010110111110], 0bin00000000@final_Ey[0bin010110111110],0bin00000000@final_Ex[0bin010111111110], 0bin00000000@final_Ey[0bin010111111110],0bin00000000@final_Ex[0bin011000001101], 0bin00000000@final_Ey[0bin011000001101],0bin00000000@final_Ex[0bin011000011001], 0bin00000000@final_Ey[0bin011000011001],0bin00000000@final_Ex[0bin011000100101], 0bin00000000@final_Ey[0bin011000100101],0bin00000000@final_Ex[0bin011000101101], 0bin00000000@final_Ey[0bin011000101101],0bin00000000@final_Ex[0bin011000111100], 0bin00000000@final_Ey[0bin011000111100],0bin00000000@final_Ex[0bin011001001000], 0bin00000000@final_Ey[0bin011001001000],0bin00000000@final_Ex[0bin011001011010], 0bin00000000@final_Ey[0bin011001011010],0bin00000000@final_Ex[0bin011001101001], 0bin00000000@final_Ey[0bin011001101001],0bin00000000@final_Ex[0bin011001110101], 0bin00000000@final_Ey[0bin011001110101],0bin00000000@final_Ex[0bin011001111101], 0bin00000000@final_Ey[0bin011001111101],0bin00000000@final_Ex[0bin011010000111], 0bin00000000@final_Ey[0bin011010000111],0bin00000000@final_Ex[0bin011010001001], 0bin00000000@final_Ey[0bin011010001001],0bin00000000@final_Ex[0bin011010010011], 0bin00000000@final_Ey[0bin011010010011],0bin00000000@final_Ex[0bin011010010101], 0bin00000000@final_Ey[0bin011010010101],0bin00000000@final_Ex[0bin011010100100], 0bin00000000@final_Ey[0bin011010100100],0bin00000000@final_Ex[0bin011010101010], 0bin00000000@final_Ey[0bin011010101010],0bin00000000@final_Ex[0bin011010101110], 0bin00000000@final_Ey[0bin011010101110],0bin00000000@final_Ex[0bin011010110010], 0bin00000000@final_Ey[0bin011010110010],0bin00000000@final_Ex[0bin011010110011], 0bin00000000@final_Ey[0bin011010110011],0bin00000000@final_Ex[0bin011010110100], 0bin00000000@final_Ey[0bin011010110100],0bin00000000@final_Ex[0bin011010111001], 0bin00000000@final_Ey[0bin011010111001],0bin00000000@final_Ex[0bin011011000000], 0bin00000000@final_Ey[0bin011011000000],0bin00000000@final_Ex[0bin011011100001], 0bin00000000@final_Ey[0bin011011100001],0bin00000000@final_Ex[0bin011100001010], 0bin00000000@final_Ey[0bin011100001010],0bin00000000@final_Ex[0bin011100001110], 0bin00000000@final_Ey[0bin011100001110],0bin00000000@final_Ex[0bin011100110100], 0bin00000000@final_Ey[0bin011100110100],0bin00000000@final_Ex[0bin011100111000], 0bin00000000@final_Ey[0bin011100111000],0bin00000000@final_Ex[0bin011100111100], 0bin00000000@final_Ey[0bin011100111100],0bin00000000@final_Ex[0bin011100111101], 0bin00000000@final_Ey[0bin011100111101],0bin00000000@final_Ex[0bin011100111110], 0bin00000000@final_Ey[0bin011100111110],0bin00000000@final_Ex[0bin011101000011], 0bin00000000@final_Ey[0bin011101000011],0bin00000000@final_Ex[0bin011101001010], 0bin00000000@final_Ey[0bin011101001010],0bin00000000@final_Ex[0bin011101100010], 0bin00000000@final_Ey[0bin011101100010],0bin00000000@final_Ex[0bin011101100110], 0bin00000000@final_Ey[0bin011101100110],0bin00000000@final_Ex[0bin011101101010], 0bin00000000@final_Ey[0bin011101101010],0bin00000000@final_Ex[0bin011101101011], 0bin00000000@final_Ey[0bin011101101011],0bin00000000@final_Ex[0bin011101101100], 0bin00000000@final_Ey[0bin011101101100],0bin00000000@final_Ex[0bin011101110001], 0bin00000000@final_Ey[0bin011101110001],0bin00000000@final_Ex[0bin011101111000], 0bin00000000@final_Ey[0bin011101111000],0bin00000000@final_Ex[0bin011110001101], 0bin00000000@final_Ey[0bin011110001101],0bin00000000@final_Ex[0bin011110001111], 0bin00000000@final_Ey[0bin011110001111],0bin00000000@final_Ex[0bin011110010011], 0bin00000000@final_Ey[0bin011110010011],0bin00000000@final_Ex[0bin011110010111], 0bin00000000@final_Ey[0bin011110010111],0bin00000000@final_Ex[0bin011110011100], 0bin00000000@final_Ey[0bin011110011100],0bin00000000@final_Ex[0bin011110011110], 0bin00000000@final_Ey[0bin011110011110],0bin00000000@final_Ex[0bin011110100010], 0bin00000000@final_Ey[0bin011110100010],0bin00000000@final_Ex[0bin011110100101], 0bin00000000@final_Ey[0bin011110100101],0bin00000000@final_Ex[0bin011110101000], 0bin00000000@final_Ey[0bin011110101000],0bin00000000@final_Ex[0bin011110101011], 0bin00000000@final_Ey[0bin011110101011],0bin00000000@final_Ex[0bin011110101110], 0bin00000000@final_Ey[0bin011110101110],0bin00000000@final_Ex[0bin011110110000], 0bin00000000@final_Ey[0bin011110110000],0bin00000000@final_Ex[0bin011110111001], 0bin00000000@final_Ey[0bin011110111001],0bin00000000@final_Ex[0bin011110111100], 0bin00000000@final_Ey[0bin011110111100],0bin00000000@final_Ex[0bin011110111111], 0bin00000000@final_Ey[0bin011110111111],0bin00000000@final_Ex[0bin011111000011], 0bin00000000@final_Ey[0bin011111000011],0bin00000000@final_Ex[0bin011111001001], 0bin00000000@final_Ey[0bin011111001001],0bin00000000@final_Ex[0bin011111001011], 0bin00000000@final_Ey[0bin011111001011],0bin00000000@final_Ex[0bin011111001110], 0bin00000000@final_Ey[0bin011111001110],0bin00000000@final_Ex[0bin011111010001], 0bin00000000@final_Ey[0bin011111010001],0bin00000000@final_Ex[0bin011111010101], 0bin00000000@final_Ey[0bin011111010101],0bin00000000@final_Ex[0bin011111010111], 0bin00000000@final_Ey[0bin011111010111],0bin00000000@final_Ex[0bin011111011010], 0bin00000000@final_Ey[0bin011111011010],0bin00000000@final_Ex[0bin011111011101], 0bin00000000@final_Ey[0bin011111011101],0bin00000000@final_Ex[0bin011111011111], 0bin00000000@final_Ey[0bin011111011111],0bin00000000@final_Ex[0bin011111101001], 0bin00000000@final_Ey[0bin011111101001],0bin00000000@final_Ex[0bin011111101111], 0bin00000000@final_Ey[0bin011111101111],0bin00000000@final_Ex[0bin011111111000], 0bin00000000@final_Ey[0bin011111111000],0bin00000000@final_Ex[0bin011111111010], 0bin00000000@final_Ey[0bin011111111010],0bin00000000@final_Ex[0bin011111111110], 0bin00000000@final_Ey[0bin011111111110],0bin00000000@final_Ex[0bin100000000001], 0bin00000000@final_Ey[0bin100000000001],0bin00000000@final_Ex[0bin100000000100], 0bin00000000@final_Ey[0bin100000000100],0bin00000000@final_Ex[0bin100000000111], 0bin00000000@final_Ey[0bin100000000111],0bin00000000@final_Ex[0bin100000010011], 0bin00000000@final_Ey[0bin100000010011]) );
-ASSERT (BVGE(total_energy, 0bin0000000110010000));
-QUERY FALSE;
projects / francis / stp.git / commitdiff